Listy przechwytywania domknięć i [weak self]

Domknięcia przechwytują zmienne z otaczającego zakresu. Listy przechwytywania (`[weak self]`, `[unowned self]`, `[value]`) dokładnie określają sposób wykonywania tych przechwyceń.

```swift var name = "Alice" let greet = { print("Hello, \(name)") } name = "Bob" greet() // "Hello, Bob" — closure sees current value ``` Domyślnie domknięcia przechwytują *referencje* do zmiennych.

```swift var count = 10 let snapshot = { [count] in print(count) } // captures value count = 99 snapshot() // 10 — snapshot of count at capture time ``` Umieszczenie typu wartości w `[]` kopiuje tę wartość w chwili utworzenia domknięcia.

```swift class API { func fetch(completion: @escaping () -> Void) { ... } } class VC { func load() { api.fetch { [weak self] in guard let self else { return } // self might be nil by now self.updateUI() } } } ```

Swift 5.3+: można ponownie powiązać `self` wewnątrz instrukcji guard bez tworzenia aliasu: ```swift { [weak self] in guard let self else { return } // 'self' is now strong within this block doA() doB() doC() } ```

```swift button.addTarget(self, action: #selector(tap), for: .touchUpInside) // If the button's closure is guaranteed not to outlive self: let action: () -> Void = { [unowned self] in self.handleTap() } ```

```swift let base = 100 let multiplier = 2 let compute = { [base, multiplier] in base * multiplier } print(compute()) // 200 ``` W jednej liście można przechwycić wiele wartości, oddzielając je przecinkami.

```swift let myService = service // rename in capture list: let handler = { [service = myService] in service.process() } ``` Jest to przydatne, gdy chcą Państwo przechwycić konkretną migawkę pod nową nazwą.

• Domknięcie `@escaping` może zostać zapisane i wywołane po zwróceniu funkcji → ryzyko cykli • Domknięcie non-escaping jest wywoływane przed zwróceniem funkcji → brak ryzyka cyklu ```swift func apply(_ f: () -> Void) { f() } // non-escaping, no [weak] needed func later(_ f: @escaping () -> Void) { queue.async { f() } } // escaping ```

Jeśli podejrzewają Państwo cykl: 1. Należy dodać `deinit { print("deallocated") }` do klasy 2. Należy przejść do innego widoku lub ustawić instancję na nil 3. Jeśli `deinit` niczego nie wypisze → istnieje cykl Następnie należy dodać `[weak self]` do domknięć w tej klasie.

Najważniejsze informacje: • Domknięcia domyślnie przechwytują referencje • Lista przechwytywania `[value]` kopiuje typy wartości w chwili utworzenia • `[weak self]` — nie zwiększa licznika referencji, automatycznie przyjmuje wartość nil; należy używać `guard let self` • `[unowned self]` — nie zwiększa licznika referencji i nie jest bezpieczne dla wartości nil • Domknięcia `@escaping` wymagają list przechwytywania; domknięcia non-escaping zwykle ich nie wymagają Kurs ukończony! Następny temat: programowanie funkcyjne w Swift.