Vai vienmēr ir nepieciešams izmantot weak vai unowned…

Nē, ne vienmēr.

Weak un unowned tiek izmantoti, lai novērstu stipro atsauces ciklu (retain cycles) slēgtajos blokos, kad slēgums tur stipru atsauci uz objektu, un objekts savukārt tur stipru atsauci uz slēgumu.

weak vai unowned ir jālieto, kad slēgums ietver stipru atsauci uz self vai citu atsauces tipu, un pastāv iespēja, ka var rasties stipro atsauces ciklu.

Situācijas, kad nevajag izmantot weak/unowned:

Slēgums ietver vērtību tipus (struktūras, enumerācijas, kopa). Tie tiek kopēti, kad tiek ietverti, un stipro atsauces cikli nerodas.
Slēgums ietver atsauces tipu, bet nav abpusējs stiprs atsauces cikls. Piemēram, ja slēgums ir izveidots vietēji metodē un netiek saglabāts objektā, uz kuru tas atsaucas.
Slēgums ir īslaicīgs un tiks izpildīts pirms objekta, uz kuru tas atsaucas, tiek atbrīvots. Piemēram, slēgums, kas tiek nodots kā Completion Handler un tiek nekavējoties izpildīts.

Izvēle starp weak un unowned:

weak: Izmanto, ja ietvertais objekts var kļūt par nil jebkurā laikā pirms slēguma izpildes. Atsauce ir opcionala (ObjectType?). Prasa pārbaudi uz nil pirms lietošanas.
unowned: Izmanto, ja ir zināms, ka ietvertais objekts vienmēr pastāvēs slēguma izpildes laikā. Atsauce nav opcionala (ObjectType). Nav nepieciešama pārbaude uz nil. unowned izmantošana objektam, kurš kļuva par nil, novedīs pie avārijas (runtime error).

// Piemērs, kad nav nepieciešams weak/unowned (struktūras ietveršana)
struct MyStruct {
    var value: Int
}

let myStruct = MyStruct(value: 10)
let closure = {
    print(myStruct.value) // ietver myStruct kopiju
}
closure()

// Piemērs, kad nav nepieciešams weak/unowned (vietējs slēgums)
class MyClass {
    func doSomething() {
        let localValue = 5
        let localClosure = {
            print(self.description) // ietver self, bet slēgums netiek saglabāts kā objekts
        }
        localClosure()
    }

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

let myObject = MyClass()
myObject.doSomething()

// Piemērs, kad nepieciešams weak (var kļūt par nil)
class AsyncOperation {
    var completionHandler: (() -> Void)?

    func performOperation() {
        // Asinhronās darbības imitācija
        DispatchQueue.global().async {
            print("Operation completed")
            self.completionHandler?() // nulle opcionalā ķēde
        }
    }

    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")
    }
}

// Piemērs, kad nepieciešams unowned (garantēti pastāv)
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")
    }
}

Vai vienmēr ir nepieciešams izmantot weak vai unowned Capture List?