Swift Academy · Leçon

Liaison avec if let et guard let

Déballez les optionnels en toute sécurité avec des schémas de liaison conditionnelle et de sortie anticipée.

Liaison avec if let et guard let est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 1 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.

Bienvenue

Les optionnels représentent des valeurs qui peuvent exister ou non. Le déballage sécurisé avec `if let` et `guard let` est la base d’un code Swift sans plantage.

Qu’est-ce qu’un optionnel ?

```swift var name: String? = "Alice" // has a value var age: Int? = nil // no value ``` Un optionnel encapsule une valeur dans `.some(value)` ou `.none`. Vous devez le déballer avant de l’utiliser.

if let — Liaison conditionnelle

```swift if let name = name { print("Hello, \(name)!") // name is String here } else { print("No name provided") } ``` Dans le bloc `if`, `name` est une `String` non optionnelle.

if let avec le même nom (Swift 5.7+)

Depuis Swift 5.7, vous pouvez réutiliser le même nom de variable : ```swift if let name { print("Hello, \(name)!") } ``` C’est plus court et plus clair : il n’est pas nécessaire d’écrire `let name = name`.

guard let — Sortie anticipée

`guard let` déballe la valeur et quitte la fonction immédiatement si elle vaut nil : ```swift func greet(_ name: String?) { guard let name else { return } print("Hello, \(name)!") } ``` Après le `guard`, il est garanti que `name` n’est pas nil pour le reste de la fonction.

Chaîner plusieurs liaisons

Déballez plusieurs optionnels dans une seule instruction : ```swift if let first = firstName, let last = lastName { print("\(first) \(last)") } guard let id = userId, let token = authToken else { return } ``` Toutes les liaisons doivent réussir pour que le corps s’exécute.

Ajouter une condition where

Combinez le déballage avec une condition : ```swift if let score = rawScore, score >= 60 { print("Passed with \(score)") } ``` La liaison et la condition sont évaluées ensemble, ce qui est plus clair qu’un `if` imbriqué.

guard let ou if let

Utilisez `if let` lorsque les deux branches ont besoin de la valeur. Utilisez `guard let` pour vérifier les conditions préalables et quitter la fonction immédiatement : ```swift // if let: handle both cases if let data = response.data { process(data) } else { showError() } // guard: ensure requirements are met guard let data = response.data else { showError(); return } process(data) ```

if let imbriqué ou guard

Un `if let` profondément imbriqué, parfois appelé « pyramide du désespoir », est plus difficile à lire : ```swift if let a = aOpt { if let b = bOpt { if let c = cOpt { process(a, b, c) } } } ``` Réécrivez-le avec `guard` : ```swift guard let a = aOpt, let b = bOpt, let c = cOpt else { return } process(a, b, c) ```

Vérifier sans liaison

Utilisez `!= nil` lorsque vous avez seulement besoin de savoir si une valeur existe : ```swift if token != nil { showLoggedInUI() } ``` Mais préférez `if let` lorsque vous avez également besoin de la valeur déballée.

Vérification rapide

Quelle instruction quitte la portée actuelle si l’optionnel vaut `nil` ?

Récapitulatif

Points essentiels : • `if let x = optional` — branchement sûr vers un contexte où la valeur n’est pas nil • `guard let x = optional else { return }` — sortie anticipée immédiate en cas d’échec • Chaînez plusieurs liaisons avec des virgules • `guard let` évite les pyramides profondément imbriquées • Swift 5.7+ : `if let x` (forme abrégée avec le même nom) Ensuite : la coalescence de nil et l’opérateur ??

Questions Fréquemment Posées

La leçon « Liaison avec if let et guard let » est-elle gratuite ?

Oui — le texte complet de « Liaison avec if let et guard let » 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 « Liaison avec if let et guard let » ?

Déballez les optionnels en toute sécurité avec des schémas de liaison conditionnelle et de sortie anticipée. 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 4.

Combien de temps prend la leçon « Liaison avec if let et guard let » ?

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

Liaison avec if let et guard let
Coalescence de nil et opérateur ternaire avec les optionnels
Chaînage optionnel avec ?.
Optionnels déballés implicitement et situations à éviter

← Retour à Swift Academy