Swift Academy · Leçon

Fermetures échappantes

Stockez des fermetures qui survivent à leur fonction.

Fermetures échappantes est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 2 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.

Échappante ou non échappante

Par défaut, un paramètre de fermeture est non échappant : il doit être appelé avant le retour de la fonction. Marquez-le avec @escaping s’il peut être stocké et appelé ultérieurement.

Une fermeture non échappante

Cette fermeture s’exécute de manière synchrone et disparaît lorsque la fonction renvoie son résultat :

func run(_ work: () -> Void) {
    work()
}
run { print("done now") }  // "done now"

Pourquoi @escaping est nécessaire

Stocker une fermeture pour l’utiliser ultérieurement nécessite @escaping :

var handlers: [() -> Void] = []
func register(_ handler: @escaping () -> Void) {
    handlers.append(handler)  // escapes the function
}
register { print("later") }
handlers[0]()  // "later"

Échappante avec un travail asynchrone

Les gestionnaires de fin s’échappent, car ils s’exécutent après le retour de la fonction :

func load(then completion: @escaping (String) -> Void) {
    // imagine async work
    completion("data")
}
load { result in print(result) }  // "data"

self doit être explicite

Dans une fermeture échappante, vous devez écrire explicitement self. lorsque vous accédez aux membres de l’instance — cela rappelle que la fermeture peut conserver self.

self explicite dans une fermeture échappante

Le compilateur exige la référence explicite :

class Loader {
    var name = "L"
    func start(_ done: @escaping () -> Void) {
        let cb = { print(self.name); done() }
        cb()
    }
}
Loader().start { print("finished") }  // "L" then "finished"

Stocker plusieurs rappels

Les fermetures échappantes vous permettent de créer des listes d’observateurs :

class Emitter {
    private var listeners: [(Int) -> Void] = []
    func on(_ l: @escaping (Int) -> Void) { listeners.append(l) }
    func fire(_ v: Int) { listeners.forEach { $0(v) } }
}
let e = Emitter()
e.on { print("got \($0)") }
e.fire(7)  // "got 7"

Renvoyer une fermeture stockée

Les fermetures conservées dans des propriétés sont échappantes :

class Button {
    var action: (() -> Void)?
    func setAction(_ a: @escaping () -> Void) { action = a }
}
let b = Button()
b.setAction { print("tapped") }
b.action?()  // "tapped"

Les fermetures optionnelles s’échappent

Un paramètre de fermeture optionnel est implicitement échappant (il est encapsulé dans une valeur optionnelle), et peut donc être stocké :

func maybe(_ f: (() -> Void)?) {
    f?()
}
maybe { print("ran") }  // "ran"

Échapper une fermeture dans un tableau de tasks

Une file de travail différé constitue un cas d’utilisation classique des fermetures échappantes — chaque fermeture est stockée, puis exécutée ultérieurement :

var tasks: [() -> Int] = []
func schedule(_ task: @escaping () -> Int) {
    tasks.append(task)
}
schedule { 1 + 1 }
schedule { 10 * 2 }
print(tasks.map { $0() })  // [2, 20]

Remarque sur les performances

Les fermetures non échappantes peuvent être optimisées plus agressivement (aucune allocation sur le tas n’est nécessaire). Gardez les fermetures non échappantes lorsque c’est possible ; ne les rendez échappantes que lorsque vous les stockez ou différez réellement leur exécution.

func sum(_ xs: [Int], _ f: (Int) -> Int) -> Int {
    xs.reduce(0) { $0 + f($1) }   // non-escaping, fast
}
print(sum([1, 2, 3]) { $0 * $0 })  // 14

Vérification rapide

Quand un paramètre de fermeture doit-il être marqué avec @escaping ?

Récapitulatif

Vous avez appris les fermetures échappantes :

Les fermetures non échappantes sont le comportement par défaut ; elles s’exécutent avant le retour de la fonction
@escaping est nécessaire pour stocker ou différer une fermeture
Les fermetures échappantes nécessitent un accès explicite à self.
Les paramètres de fermeture optionnels s’échappent implicitement ; préférez les fermetures non échappantes pour de meilleures performances

Ensuite : les listes de capture et self faible.

Questions Fréquemment Posées

La leçon « Fermetures échappantes » est-elle gratuite ?

Oui — le texte complet de « Fermetures échappantes » 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 « Fermetures échappantes » ?

Stockez des fermetures qui survivent à leur fonction. 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 2 sur 4.

Combien de temps prend la leçon « Fermetures échappantes » ?

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