Este întotdeauna necesar să folosiți weak sau unowned…

Nu, nu întotdeauna.

Weak și unowned sunt folosite pentru a preveni ciclurile de referințe puternice (retention cycles) în closures, atunci când closure-ul menține o referință puternică la un obiect, iar obiectul menține la rândul său o referință puternică la closure.

Este necesar să folosiți weak sau unowned atunci când closure-ul capturează o referință puternică la self sau la un alt tip referențial, și există riscul de a apărea un ciclu de referințe puternice.

Situații în care nu este nevoie să folosiți weak/unowned:

Closure-ul capturează tipuri de valoare (structuri, enumerări, tuple-uri). Acestea sunt copiate la capturare, și nu apar cicluri de referințe puternice.
Closure-ul capturează un tip referențial, dar nu există un ciclu bidirecțional de referințe puternice. De exemplu, dacă closure-ul este creat local în interiorul unei metode și nu este stocat într-un obiect la care face referire.
Closure-ul are o durată de viață scurtă și va fi executat înainte ca obiectul la care face referire să fie eliberat. De exemplu, un closure transmis ca Handler de finalizare, care se execută imediat.

Alegerea între weak și unowned:

weak: Se folosește atunci când obiectul capturat poate deveni nil în orice moment înainte de executarea closure-ului. Referința este declarată ca opțională (ObjectType?). Este necesar să verificați nil înainte de utilizare.
unowned: Se folosește atunci când se știe că obiectul capturat va exista întotdeauna în momentul executării closure-ului. Referința nu este opțională (ObjectType). Nu necesită verificare de nil. Utilizarea unowned pentru un obiect care a devenit nil va duce la o eroare de rulare (runtime error).

// Exemplu în care nu sunt necesare `weak`/`unowned` (capturare structură)
struct MyStruct {
    var value: Int
}

let myStruct = MyStruct(value: 10)
let closure = {
    print(myStruct.value) // Capturează o copie a lui myStruct
}
closure()

// Exemplu în care nu sunt necesare `weak`/`unowned` (closure local)
class MyClass {
    func doSomething() {
        let localValue = 5
        let localClosure = {
            print(self.description) // Capturează self, dar closure-ul nu este stocat în MyClass
        }
        localClosure()
    }

    var description: String {
        return "Instance of MyClass"
    }
}

let myObject = MyClass()
myObject.doSomething()

// Exemplu în care este necesar `weak` (potențial nil)
class AsyncOperation {
    var completionHandler: (() -> Void)?

    func performOperation() {
        // Simulare de lucru asincron
        DispatchQueue.global().async {
            print("Operation completed")
            self.completionHandler?() // chaining opțional
        }
    }

    deinit {
        print("AsyncOperation deinitialized")
    }
}

class ViewController {
    var op: AsyncOperation?

    func setupOperation() {
        op = AsyncOperation()
        op?.completionHandler = { [weak self] in // weak self
            guard let self = self else { return }
            print("Completion handler in ViewController: \(self)")
        }
    }

    deinit {
        print("ViewController deinitialized")
    }
}

// Exemplu în care este necesar `unowned` (garantat existent)
class Button {
    var action: (() -> Void)?

    func tap() {
        action?()
    }

    deinit {
        print("Button deinitialized")
    }
}

class ViewControllerWithButton {
    var button: Button

    init() {
        button = Button()
        button.action = { [unowned self] in // unowned self
            print("Button tapped in ViewControllerWithButton: \(self)")
        }
    }

    deinit {
        print("ViewControllerWithButton deinitialized")
    }
}

Este întotdeauna necesar să folosiți weak sau unowned în lista de captură?