Références weak et unowned

Pour rompre les cycles de rétention, il faut utiliser des références qui n’incrémentent pas le compteur ARC. Swift en fournit deux : `weak` (facultative, remise automatiquement à zéro) et `unowned` (non facultative, dangereuse si elle vaut nil).

```swift class Owner { var pet: Pet? } class Pet { weak var owner: Owner? } // does not retain var o: Owner? = Owner() var p: Pet? = Pet() o?.pet = p p?.owner = o o = nil // Owner deinit — p.owner becomes nil automatically ```

```swift class View { weak var delegate: ViewDelegate? } ``` `weak` doit être `var` et facultatif — Swift le remet automatiquement à zéro lorsque l’objet référencé est désalloué.

```swift class Customer { var card: CreditCard? } class CreditCard { unowned let customer: Customer // card always has a customer init(customer: Customer) { self.customer = customer } } ``` `unowned` ne retient pas l’objet et n’est pas facultatif — vous garantissez que l’objet référencé survivra à celui-ci.

| Situation | Utilisation | |---|---| | L’objet référencé peut devenir nil | `weak` | | L’objet référencé survit toujours à celui-ci | `unowned` | | Vous hésitez | `weak` (plus sûr) |

```swift var customer: Customer? = Customer() var card = CreditCard(customer: customer!) customer = nil print(card.customer.name) // 💥 crash — unowned is dangling ``` N’accédez jamais à `unowned` après la désallocation de l’objet référencé.

```swift class VC { func load() { api.fetch { [weak self] data in guard let self else { return } self.render(data) } } } ``` `[weak self]` est la correction de cycle de rétention la plus courante en Swift.

```swift class Session { var onComplete: (() -> Void)? init() { onComplete = { [unowned self] in // self always outlives closure self.finish() } } } ``` Utilisez `[unowned self]` uniquement lorsque vous êtes certain que `self` ne sera pas nil lors de l’exécution de la fermeture.

```swift class Timer { weak var delegate: TimerDelegate? } var d: TimerDelegate? = ConcreteDelegate() let t = Timer() t.delegate = d d = nil print(t.delegate) // nil — automatically zeroed ```

Déclarez toujours les propriétés de délégué comme `weak` : ```swift protocol MyDelegate: AnyObject { func didUpdate() } class MyView { weak var delegate: MyDelegate? } ``` La contrainte `AnyObject` est requise pour utiliser `weak` avec les protocoles.

Points clés : • `weak` — facultatif, remis automatiquement à zéro, sûr • `unowned` — non facultatif, garantit que l’objet référencé lui survivra, provoque un plantage en cas d’erreur • Modèles délégué : utilisez toujours `weak var delegate: Protocol?` avec une contrainte `AnyObject` • Fermetures : `[weak self]` est le modèle standard ; utilisez `guard let self` à l’intérieur • En cas de doute, choisissez `weak` plutôt que `unowned` Ensuite : les listes de capture des fermetures.