Swift Academy · Leçon

Chaînage optionnel avec ?.

Appelez des méthodes et accédez aux propriétés d’optionnels sans provoquer de plantage.

Chaînage optionnel avec ?. 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.

Bienvenue

Le chaînage des optionnels permet d’appeler des méthodes, d’accéder à des propriétés et d’utiliser des sous-scripts au travers d’une chaîne d’optionnels, en toute sécurité. Si un maillon de la chaîne vaut nil, toute l’expression retourne nil sans provoquer de plantage.

L’opérateur ?.

```swift struct Address { var city: String } struct Person { var address: Address? } let alice = Person(address: Address(city: "Istanbul")) let bob = Person(address: nil) print(alice.address?.city) // Optional("Istanbul") print(bob.address?.city) // nil ```

Chaîner plusieurs niveaux

Les chaînes peuvent avoir une profondeur arbitraire : ```swift struct Company { var ceo: Person? } let company = Company(ceo: alice) let city = company.ceo?.address?.city print(city ?? "Unknown") // "Istanbul" ``` Si `ceo` ou `address` vaut nil, `city` devient nil.

Appeler des méthodes par chaînage

Les méthodes peuvent également être appelées au moyen du chaînage des optionnels : ```swift var name: String? = "alice" let upper = name?.uppercased() // Optional("ALICE") name = nil let upper2 = name?.uppercased() // nil ``` Le type de retour devient optionnel : `String` devient `String?`.

Sous-scripts par chaînage

```swift var dict: [String: [Int]]? = ["scores": [10, 20, 30]] let first = dict?["scores"]?[0] // Optional(10) dict = nil let none = dict?["scores"]?[0] // nil ``` Les sous-scripts fonctionnent comme les propriétés et les méthodes dans une chaîne.

Le chaînage produit un optionnel

Même si le résultat final n’est pas optionnel, le chaînage l’encapsule dans un optionnel : ```swift struct Cat { var lives: Int = 9 } var cat: Cat? = Cat() let lives = cat?.lives // Int? not Int ``` Déballez-le avec `??`, `if let` ou `guard let` selon vos besoins.

Définir des valeurs par chaînage

Vous pouvez définir des propriétés à l’aide de chaînes optionnelles : ```swift var profile: UserProfile? = UserProfile() profile?.name = "Alice" ``` Si `profile` vaut nil, l’affectation est ignorée silencieusement (aucun plantage).

Appeler des méthodes sans valeur de retour par chaînage

```swift var manager: SoundManager? manager?.play() // silently ignored if nil ``` L’appel renvoie `Void?` — `()` s’il n’est pas nul, `nil` si l’optionnel était nul. Vous pouvez vérifier le résultat pour savoir si l’appel a bien eu lieu.

Chaînage optionnel ou désenveloppement forcé

```swift // Forced unwrap — crashes if nil: let city = alice.address!.city // Optional chaining — safe: let city = alice.address?.city ``` Préférez toujours le chaînage optionnel. Utilisez `!` uniquement lorsque vous êtes certain qu’une valeur nulle ne peut pas apparaître.

Combiner avec ?? pour définir des valeurs par défaut

Enchaînez `??` après un chaînage optionnel pour définir proprement des valeurs par défaut : ```swift let displayCity = user.profile?.address?.city ?? "Unknown City" let count = database?.records?.count ?? 0 ``` Toute la chaîne aboutit soit à une valeur, soit à la valeur par défaut.

Vérification rapide

Si un maillon d’une chaîne optionnelle vaut `nil`, que renvoie l’expression entière ?

Récapitulatif

Points essentiels : • `?.` accède de manière sûre aux propriétés, appelle des méthodes et utilise des indices sur les optionnels • Si un maillon vaut nil, toute la chaîne renvoie nil • Le type du résultat est toujours optionnel (même si la valeur finale ne l’est normalement pas) • Combinez `?.` avec `??` pour obtenir des accès sûrs suivis de valeurs par défaut • Préférez `?.` à `!` pour éviter les plantages Ensuite : les optionnels implicitement désenveloppés.

Questions Fréquemment Posées

La leçon « Chaînage optionnel avec ?. » est-elle gratuite ?

Oui — le texte complet de « Chaînage optionnel avec ?. » 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 « Chaînage optionnel avec ?. » ?

Appelez des méthodes et accédez aux propriétés d’optionnels sans provoquer de plantage. 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 « Chaînage optionnel avec ?. » ?

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