Swift Academy · Leçon

Fermetures

Fermetures est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 1. 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 1 leçons au total.

Introduction

Bonjour,

Les fermetures sont des blocs de code autonomes. Une fermeture peut être transmise au code en tant que paramètre ou être utilisée à l’intérieur du code.

Une fermeture est un type de fonction. Elle peut être utilisée en la transmettant au code. Elle ressemble aux fonctions lambda d’autres langages de programmation.

Gestion de la mémoire

L’un des points les plus importants est qu’une fermeture peut stocker les valeurs des constantes et des variables dans le contexte où elle est définie.

Ce stockage est appelé capture des valeurs.

Swift gère la mémoire pour nous pendant ce stockage.

Types de fermetures

Il existe plusieurs types de fermetures.

Les fonctions globales sont des fermetures nommées. Elles ne conservent aucune valeur.
Les fonctions imbriquées peuvent conserver les valeurs du nom et de la fonction qui les contient.
Les expressions de fermeture, quant à elles, sont des fermetures anonymes qui peuvent stocker les données du contexte qui les entoure grâce à une syntaxe simple.

Syntaxe des fermetures

La syntaxe des fermetures est simplifiée autant que possible. Voici les principaux éléments à retenir.

Les paramètres des fermetures peuvent être déduits.
Les valeurs de retour peuvent être déduites.
Une fermeture peut être renvoyée sur une seule ligne.
Les noms des arguments peuvent être exprimés sous forme abrégée, comme $ 0 ou $ 1.
La syntaxe des fermetures finales peut être utilisée.

Informations

Les expressions de fermeture consistent à écrire les fermetures directement dans le code, en privilégiant la syntaxe et la simplicité.

Syntaxe d’une fermeture

La syntaxe d’une fermeture est présentée dans l’exemple de code ci-dessous.

{ (parameters) -> return type in
    statements
}


func backward(_ s1: String, _ s2: String) -> Bool {
    return s1 > s2
}
//If we didn't use closures, our code structure would be as follows.

var reversedNames = names.sorted(by: backward)

Syntaxe d’une fermeture

Avec une fermeture, nous n’avons toutefois pas besoin de définir inutilement une fermeture globale nommée de ce type.

Il suffit de définir une simple expression de fermeture en tant que paramètre. Examinons l’exemple.

let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
let reversedNames = names.sorted(by: { (s1: String, s2: String) -> Bool in
    return s1 > s2
})

print(reversedNames)

///sorted method takes closure as parameter.

Mot-clé in

Le mot-clé in indique que le corps de la fermeture commence.

Avant le mot-clé in, les paramètres reçus par la fermeture et le type de retour doivent être définis.

Déduire le type à partir du contexte

Déduire les types à partir du contexte

Dans l’exemple ci-dessus, l’expression de fermeture peut être comprise en déduisant les paramètres et le type de retour, puisque la méthode sorted reçoit une fermeture.

Nous n’avons donc pas besoin de les définir séparément.

Dans cet exemple, nous comprenons que, puisque les valeurs du tableau names sont des chaînes, les paramètres reçus par la fermeture seront de type String.

De même, la fermeture concernée doit renvoyer une valeur de type Bool pour effectuer le tri ; le type de retour sera donc déduit comme étant Bool.

Exemple

Cela simplifie l’utilisation présentée ci-dessous.

La flèche peut également être omise du code en déduisant le type de retour.

let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
let reversedNames = names.sorted(by: { (s1: String, s2: String) -> Bool in
    return s1 > s2
})

print(reversedNames)

Syntaxe abrégée

Il est préférable d’utiliser la syntaxe longue plutôt que la syntaxe abrégée afin d’éviter de dérouter les lecteurs du code.

La syntaxe ci-dessus peut être encore raccourcie.

La valeur de retour peut être raccourcie dans l’expression de fermeture en supprimant le mot-clé return.

/*
In this example, the return keyword has been extracted.
It already has single expression. 
There is no need to express it as an extra with return.
*/

var names = ["Coddy", "Kit"]
let reversedNames = names.sorted(by: { s1, s2 in s1 > s2 } )
print(reversedNames)

Exemple

Dans cet exemple, le mot-clé return a été omis.

Il n’y a déjà qu’une seule expression, il n’est donc pas nécessaire de l’indiquer explicitement avec return.

reversedNames = names.sorted(by: { s1, s2 in s1 > s2 } )

Raccourci de nom

La syntaxe peut être encore raccourcie. Dans l’exemple ci-dessus, nous avons indiqué que la fermeture recevait deux paramètres, notamment s1 et s2. Leurs types sont déduits.

Nous pouvons maintenant éviter d’exprimer ces paramètres et de définir leurs types grâce aux raccourcis.

De plus, puisqu’il n’y a ni définition des paramètres ni transmission d’une valeur de retour, le mot-clé in peut également être omis.

let names = ["Coddy", "Kit"]
let reversedNames = names.sorted(by: { $0 > $1 } )
print(reversedNames)

// In this example $0 will shortcut the first parameter and $1 will shortcut the second parameter.

Exemple abrégé

var names = ["Coddy", "Kit"]

let reversedNames = names.sorted(by: >)
print(reversedNames)
// Greater than operator takes two parameters and the rotation type is squat.

TRAILING CLOSURE

Fermeture finale

Si le paramètre transmis à une fonction de fermeture est le dernier argument de la fonction et que l’expression de fermeture est longue, il peut être plus pratique de l’écrire sous la forme d’une instruction de fermeture finale.

Nous pouvons utiliser la fermeture finale comme raccourci syntaxique. Cela permet d’améliorer la lisibilité du code.

Le dernier paramètre de la plupart des méthodes iOS est une fermeture.

Paramètre final

Par exemple, dans cet exemple, le paramètre final est une fermeture.

class Animator {
    class func animate(withDuration duration: Double, animations: () -> Void) {
        animations()
    }
}

class MyViewController {
    func start() {
        // With the traditional method, we can call this fund as follows.
        Animator.animate(withDuration: 1, animations: { [unowned self] in
            print("red")
        })
    }
}
MyViewController().start()

Le code ci-dessus étant moins lisible, il peut être écrit comme suit

Le code ci-dessus étant moins lisible, il peut être écrit comme suit.

import Foundation
Thread.sleep(forTimeInterval: 1)
print("Background color changed to red")

Exemple

Lorsque nous utilisons la syntaxe de fermeture finale, nous n’avons pas besoin d’écrire l’étiquette de l’argument.

En effet, les fermetures font désormais partie de l’appel de la fonction.

func someFunctionThatTakesAClosure(closure: () -> Void) {
    // function body goes here
}

// Here's how you call this function without using a trailing closure:
someFunctionThatTakesAClosure(closure: {
    // closure's body goes here
})

// Here's how you call this function with a trailing closure instead:
someFunctionThatTakesAClosure() {
    // trailing closure's body goes here
}

Syntaxe

Nous pouvons considérer la syntaxe de fermeture finale comme un raccourci syntaxique. Elle rend le code plus lisible.

/*
In the example below, animations
are expressed as closure.
*/
public class func animate(withDuration: TimeInterval, animations: () -> Void)

// In traditional usage, we need to make a call like the following.
UIView.animate(withDuration: 1, animations: { [unowned self] in
    self.view.backgroundColor = UIColor.red
})

/*
In this way, both the readability of the code
increases and we avoid the use of extra brackets.
If it is as above and the last parameter of the method 
is closure, Swift allows to make a call like the one below.
*/

UIView.animate(withDuration: 1) { [unowned self] in
    self.view.backgroundColor = UIColor.red
}

Nous pouvons utiliser le code ci-dessous pour tester le code

Nous pouvons utiliser le code ci-dessous pour tester le code.


func greetThenRunClosure(name: String, closure: () -> ()) {
    print("Hello, \(name)!")
    closure()
}

greetThenRunClosure(name: "Paul") {
    print("The closure was run")
}

Capturer des valeurs avec une fermeture

Une fermeture peut conserver la valeur des variables qui entourent son environnement. Vous pouvez même modifier ces variables depuis son propre corps et y accéder.

Cela reste possible même si ces variables ne se trouvent plus dans la portée d’origine où elles ont été définies.

Suite

En général, ces données peuvent être conservées dans des fonctions imbriquées ainsi que dans des expressions de fermeture. Elles peuvent stocker les données de la fonction externe.

func makeIncrementer(forIncrement amount: Int) -> () -> Int {
    var runningTotal = 0
    func incrementer() -> Int {
        runningTotal += amount
        return runningTotal
    }
    return incrementer
}

let incrementByTen = makeIncrementer(forIncrement: 10)

print(incrementByTen())
// returns a value of 10
print(incrementByTen())
// returns a value of 20
print(incrementByTen())
// returns a value of 30

Suite

Si vous attribuez une fermeture comme propriété d’une classe, elle commence alors à conserver les références de cette instance dans la fermeture.

Un cycle de références fortes est donc créé entre la fermeture et l’instance.

Une attention particulière doit être portée aux fuites de mémoire.

Avertissement

Les fermetures et les fonctions sont des types référence.

@escaping

Nous pouvons avoir besoin de cette utilisation à de nombreux endroits où la fermeture est exécutée de manière asynchrone.

Dans les premières versions de Swift (1 et 2), les fermetures des paramètres de Swift étaient échappantes, puis elles sont devenues non échappantes. Si nous avions besoin de transmettre une fermeture non échappante, nous devions le préciser explicitement.

Dans les versions suivantes, les paramètres de fermeture sont devenus non échappants afin de réduire l’utilisation de la mémoire.

Désormais, si nous voulons définir une fermeture échappante, nous devons utiliser le mot-clé @escaping.

@ESCAPING mot-clé

Si nous voulons pouvoir appeler les fermetures attribuées à une fonction après le retour de celle-ci, nous devons les déclarer avec le mot-clé @escaping.

Les fermetures définies par défaut pour une fonction sont des types référence, mais elles n’incrémentent pas le compteur de références. En effet, au moment de l’appel, la durée de vie de cette fermeture prend fin et il n’est pas nécessaire d’augmenter le compteur de références.

Toutefois, si nous devons utiliser la fermeture reçue comme paramètre après l’appel d’une fonction, nous pouvons avoir besoin de la déclarer avec le mot-clé @escaping.

nonEscaping

Commençons par voir comment fonctionne une fermeture nonEscaping.

Lorsque cette fermeture est transmise comme paramètre à la fonction, elle est exécutée dans le corps de la fonction, puis la fonction renvoie le contrôle au compilateur.

Après le retour de la fonction, c’est-à-dire une fois l’exécution terminée, elle sort de la portée de la fermeture et est libérée de la mémoire.

Utiliser une fermeture échappante

Lorsqu’une fonction de fermeture est transmise comme argument, elle continue d’être conservée même lorsque la fonction de fermeture renvoie le contrôle et que l’exécution est terminée.

Elle occupe alors de l’espace en mémoire, jusqu’à l’exécution de la fermeture. Il existe plusieurs types de fermetures échappantes.

Félicitations

Félicitations 🎉

Nous sommes arrivés à la fin de notre leçon.

À bientôt dans la prochaine leçon 😎

Questions Fréquemment Posées

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

Oui — le texte complet de « Fermetures » 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 1 leçons au total.

Qu'est-ce que j'apprendrai dans « Fermetures » ?

Fermetures 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 1 sur 1.

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

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.

← Retour à Swift Academy