Swift Academy · Leçon

Coalescence de nil et opérateur ternaire avec les optionnels

Utilisez ?? pour définir des valeurs par défaut et enchaîner les opérateurs de coalescence de nil.

Leçon 2 sur 412 étapes

Coalescence de nil et opérateur ternaire avec les optionnels 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.

Bienvenue

L’opérateur de coalescence `??` fournit une valeur par défaut lorsqu’un optionnel vaut nil. Associé à l’opérateur ternaire, il permet de gérer les optionnels de manière concise et expressive.

L’opérateur ??

```swift let name: String? = nil let display = name ?? "Guest" print(display) // "Guest" let known: String? = "Alice" print(known ?? "Guest") // "Alice" ``` Si l’optionnel n’est pas nil, sa valeur déballée est utilisée. Sinon, la valeur par défaut est utilisée.

Évaluation en court-circuit

Le côté droit de `??` n’est évalué que lorsque le côté gauche vaut nil : ```swift func expensiveDefault() -> String { print("Computing...") return "Default" } let val: String? = "Existing" let result = val ?? expensiveDefault() // expensiveDefault not called ```

Chaîner les opérateurs ??

Chaînez plusieurs opérateurs `??` pour essayer plusieurs valeurs de repli : ```swift let primary: String? = nil let secondary: String? = nil let fallback = "Anonymous" let user = primary ?? secondary ?? fallback print(user) // "Anonymous" ``` L’évaluation s’arrête à la première valeur qui n’est pas nil.

?? avec des propriétés calculées

```swift struct Config { var theme: String? var displayTheme: String { theme ?? "light" } } var c = Config() print(c.displayTheme) // "light" c.theme = "dark" print(c.displayTheme) // "dark" ``` Un schéma propre pour fournir une valeur par défaut dans des propriétés calculées.

Opérateur ternaire avec des optionnels

L’opérateur ternaire `condition ? a : b` peut être utilisé avec des vérifications d’optionnels : ```swift let score: Int? = 85 let label = score != nil ? "\(score!)" : "No score" ``` Mais `??` est généralement plus clair : ```swift let label = score.map { "\($0)" } ?? "No score" ```

Optional.map pour transformer

Transformez la valeur encapsulée d’un optionnel sans la déballer : ```swift let maybeInt: Int? = 42 let maybeStr = maybeInt.map { "Value: \($0)" } // Optional("Value: 42") let nilInt: Int? = nil let nilStr = nilInt.map { "Value: \($0)" } // nil ```

flatMap pour chaîner les optionnels

Utilisez `flatMap` lorsque la transformation elle-même retourne un optionnel : ```swift let str: String? = "123" let num = str.flatMap { Int($0) } // Optional(123) let bad: String? = "abc" let nil2 = bad.flatMap { Int($0) } // nil ```

Opérateur d’affectation ??= (non intégré)

Swift ne fournit pas `??=` intégré, mais vous pouvez le simuler : ```swift var cache: [String: Int] = [:] // Assign only if nil: if cache["key"] == nil { cache["key"] = expensiveCompute() } // Or with a helper: func ??= (lhs: inout T?, rhs: @autoclosure () -> T) { if lhs == nil { lhs = rhs() } } ```

Recommandations de lisibilité

Choisissez l’outil approprié : • `??` — valeurs par défaut simples • `if let` — lorsque vous avez besoin de la valeur déballée dans plusieurs instructions • `guard let` — condition préalable suivie d’une sortie anticipée • `.map` / `.flatMap` — transformer sans déballer Évitez le déballage forcé avec `!`, sauf si le cas nil est réellement impossible.

Vérification rapide

Que retourne `optional ?? default` lorsque `optional` vaut `nil` ?

Réponds-y dans la leçon interactive

Récapitulatif

Points essentiels : • `a ?? b` — retourne la valeur de `a` si elle n’est pas nil, sinon `b` • Court-circuite l’évaluation : `b` n’est évalué que lorsque `a` vaut nil • Chaînage : `a ?? b ?? c` • `.map` transforme la valeur encapsulée ; `.flatMap` gère les transformations qui retournent un optionnel • Préférez `??` à un opérateur ternaire associé à un déballage forcé Ensuite : le chaînage des optionnels avec `?.`

Gratuit pour commencer

Apprends Swift avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 122
Leçons: 409

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Coalescence de nil et opérateur ternaire avec les optionnels » est-elle gratuite ?

Oui — le texte complet de « Coalescence de nil et opérateur ternaire avec les optionnels » 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 « Coalescence de nil et opérateur ternaire avec les optionnels » ?

Utilisez ?? pour définir des valeurs par défaut et enchaîner les opérateurs de coalescence de nil. 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 « Coalescence de nil et opérateur ternaire avec les optionnels » ?

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