Swift Academy · Leçon

Listes de capture et self faible

Évitez les cycles de rétention avec [weak self].

Listes de capture et self faible est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Swift Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Swift Academy comprend 4 leçons au total.

Le risque de cycle de rétention

Lorsqu’un objet stocke une fermeture échappante qui capture fortement self, chacun maintient l’autre en vie indéfiniment — c’est un cycle de rétention qui provoque une fuite mémoire.

Un cycle de références fortes

La fermeture capture fortement self et self conserve la fermeture — aucun des deux n’est jamais libéré :

class Owner {
    var onEvent: (() -> Void)?
    func setup() {
        onEvent = { print(self.describe()) }  // strong self -> cycle
    }
    func describe() -> String { "Owner" }
}
let o = Owner(); o.setup()
o.onEvent?()  // "Owner"  (but leaks)

Listes de capture

Une liste de capture au début d’une fermeture, { [weak self] in ... }, contrôle la manière dont chaque référence capturée est conservée : avec weak ou unowned plutôt que fortement.

Rompre le cycle avec une référence faible à self

[weak self] capture self comme une valeur optionnelle qui ne le maintient pas en vie :

class Owner {
    var onEvent: (() -> Void)?
    func setup() {
        onEvent = { [weak self] in
            print(self?.describe() ?? "gone")
        }
    }
    func describe() -> String { "Owner" }
}
let o = Owner(); o.setup()
o.onEvent?()  // "Owner"  (no cycle)

Une référence faible rend self optionnel

Avec [weak self], self devient Self? ; vous devez donc le déballer :

class Worker {
    var tag = "W"
    lazy var job: () -> Void = { [weak self] in
        guard let self = self else { return }
        print(self.tag)
    }
}
let w = Worker()
w.job()  // "W"

Le motif guard let self

Réaffectez self tôt afin que le reste de la fermeture utilise une référence forte et non optionnelle :

class Service {
    var name = "S"
    lazy var run: () -> Void = { [weak self] in
        guard let self else { return }
        print(self.name)
        print("still \(self.name)")
    }
}
Service().run()  // "S" / "still S"

Référence faible ou non possédée

Une référence faible produit une valeur optionnelle et reste sûre si l’objet peut avoir disparu. Une référence non possédée n’est pas optionnelle et est plus rapide, mais provoque un plantage si elle est utilisée après la désallocation de l’objet — utilisez-la uniquement lorsque vous êtes certain que self survivra à la fermeture.

Utiliser une référence non possédée

Choisissez une référence non possédée lorsque la fermeture ne peut pas survivre à self :

class Timer2 {
    var ticks = 0
    lazy var tick: () -> Void = { [unowned self] in
        self.ticks += 1
    }
}
let t = Timer2()
t.tick(); t.tick()
print(t.ticks)  // 2

Capturer des propriétés précises

Ne capturez que ce dont vous avez besoin plutôt que self tout entier — cela suffit parfois à éviter complètement le cycle :

class VM {
    let id = 42
    lazy var printer: () -> Void = { [id] in print(id) }
}
VM().printer()  // 42

Une fermeture non échappante n’a pas besoin de référence faible

Les fermetures synchrones et non échappantes, comme map, ne provoquent pas de cycles ; il est donc acceptable d’y capturer self fortement :

class Calc {
    let factor = 3
    func scale(_ xs: [Int]) -> [Int] {
        xs.map { $0 * self.factor }   // safe, non-escaping
    }
}
print(Calc().scale([1, 2]))  // [3, 6]

Règle générale

Utilisez [weak self] pour les fermetures stockées ou échappantes qui font référence à self. Utilisez une référence non possédée uniquement lorsque vous êtes certain que self restera en vie. N’utilisez pas de liste de capture pour les fermetures non échappantes.

class P {
    var n = "P"
    var stored: (() -> Void)?
    func arm() { stored = { [weak self] in print(self?.n ?? "-") } }
}
let p = P(); p.arm(); p.stored?()  // "P"

Vérification rapide

Pourquoi utiliser [weak self] dans une fermeture échappante stockée ?

Récapitulatif

Vous avez appris les listes de capture :

Une référence forte à self dans une fermeture échappante stockée crée un cycle de rétention (une fuite)
[weak self] le rompt ; self devient optionnel : utilisez guard let self
Une référence unowned n’est pas optionnelle et est plus rapide, mais provoque un plantage si self a disparu
Les fermetures non échappantes n’ont pas besoin de listes de capture

Ensuite : les fermetures automatiques.

Questions Fréquemment Posées

La leçon « Listes de capture et self faible » est-elle gratuite ?

Oui — le texte complet de « Listes de capture et self faible » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Swift Academy, passe à CoddyKit PRO. Le cours Swift Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Listes de capture et self faible » ?

Évitez les cycles de rétention avec [weak self]. Tu pratiques Swift Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Swift Academy ?

Aucune expérience préalable n'est requise. Swift Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Listes de capture et self faible » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Swift Academy ?

Oui. Chaque leçon Swift Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Swift Academy