Liste di cattura delle closure e [weak self]

Le closure catturano le variabili dall'ambito circostante. Le liste di cattura (`[weak self]`, `[unowned self]`, `[value]`) controllano esattamente il modo in cui queste catture vengono effettuate.

```swift var name = "Alice" let greet = { print("Hello, \(name)") } name = "Bob" greet() // "Hello, Bob" — closure sees current value ``` Per impostazione predefinita, le closure catturano *riferimenti* alle variabili.

```swift var count = 10 let snapshot = { [count] in print(count) } // captures value count = 99 snapshot() // 10 — snapshot of count at capture time ``` Inserire un tipo valore in `[]` ne copia il valore nel momento in cui viene creata la closure.

```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+: è possibile riassegnare `self` all'interno del guard senza usare un nome diverso: ```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 ``` Catturi più valori nella stessa lista, separandoli con virgole.

```swift let myService = service // rename in capture list: let handler = { [service = myService] in service.process() } ``` Utile per catturare uno snapshot specifico con un nuovo nome.

• Una closure `@escaping` può essere memorizzata e chiamata dopo il ritorno della funzione → rischio di cicli • Una closure non-escaping viene chiamata prima del ritorno della funzione → nessun rischio di cicli ```swift func apply(_ f: () -> Void) { f() } // non-escaping, no [weak] needed func later(_ f: @escaping () -> Void) { queue.async { f() } } // escaping ```

Se sospetta un ciclo: 1. Aggiunga `deinit { print("deallocated") }` alla classe 2. Torni alla schermata precedente o imposti l'istanza su nil 3. Se deinit non stampa nulla → esiste un ciclo Aggiunga quindi `[weak self]` alle closure di quella classe.

Punti chiave: • Le closure catturano i riferimenti per impostazione predefinita • La lista di cattura `[value]` copia i tipi valore al momento della creazione • `[weak self]`: nessun retain, diventa automaticamente nil; usi `guard let self` • `[unowned self]`: nessun retain, non è sicuro rispetto a nil • Le closure `@escaping` richiedono liste di cattura; quelle non-escaping in genere no Corso completato! Successivo: programmazione funzionale in Swift.