Swift Academy · Lezione

Nil coalescing e ternario con gli optional

Utilizzi ?? per i valori predefiniti e concateni operatori nil-coalescing.

Nil coalescing e ternario con gli optional è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Swift Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Swift Academy include 4 lezioni in totale.

Benvenuto

L'operatore di coalescenza nil `??` fornisce un valore predefinito quando un optional è nil. In combinazione con l'operatore ternario, consente di gestire gli optional in modo conciso ed espressivo.

L'operatore ??

```swift let name: String? = nil let display = name ?? "Guest" print(display) // "Guest" let known: String? = "Alice" print(known ?? "Guest") // "Alice" ``` Se l'optional non è nil, viene usato il suo valore dopo l'unwrapping. Altrimenti viene usato il valore predefinito.

Valutazione short-circuit

Il lato destro di `??` viene valutato solo quando il lato sinistro è nil: ```swift func expensiveDefault() -> String { print("Computing...") return "Default" } let val: String? = "Existing" let result = val ?? expensiveDefault() // expensiveDefault not called ```

Concatenare ??

Concateni più operatori `??` per provare diversi valori alternativi: ```swift let primary: String? = nil let secondary: String? = nil let fallback = "Anonymous" let user = primary ?? secondary ?? fallback print(user) // "Anonymous" ``` La valutazione si interrompe al primo valore non nil.

?? con proprietà calcolate

```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 modello pulito per i valori predefiniti nelle proprietà calcolate.

Operatore ternario con gli optional

Il ternario `condition ? a : b` può essere usato per verificare gli optional: ```swift let score: Int? = 85 let label = score != nil ? "\(score!)" : "No score" ``` Tuttavia, `??` è in genere più leggibile: ```swift let label = score.map { "\($0)" } ?? "No score" ```

Optional.map per le trasformazioni

Trasformi il valore contenuto in un optional senza eseguire l'unwrapping: ```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 per il chaining degli optional

Usi `flatMap` quando la trasformazione restituisce a sua volta un optional: ```swift let str: String? = "123" let num = str.flatMap { Int($0) } // Optional(123) let bad: String? = "abc" let nil2 = bad.flatMap { Int($0) } // nil ```

Operatore di assegnazione ??= (non integrato)

Swift non include `??=` tra gli operatori integrati, ma può simularlo: ```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() } } ```

Linee guida per la leggibilità

Scelga lo strumento giusto: • `??` — valori predefiniti semplici • `if let` — quando le serve il valore dopo l'unwrapping in più istruzioni • `guard let` — prerequisito e uscita anticipata • `.map` / `.flatMap` — trasformazioni senza eseguire l'unwrapping Eviti l'unwrapping forzato con `!`, a meno che il caso nil non possa davvero verificarsi.

Verifica rapida

Che cosa restituisce `optional ?? default` quando `optional` è `nil`?

Riepilogo

Punti chiave: • `a ?? b` — restituisce il valore di `a` se non è nil, altrimenti `b` • Valutazione short-circuit: `b` viene valutato solo quando `a` è nil • Concatenazione: `a ?? b ?? c` • `.map` trasforma il valore contenuto; `.flatMap` gestisce le trasformazioni che restituiscono un optional • Preferisca `??` al ternario con unwrapping forzato Prossima lezione: optional chaining con `?.`

Domande Frequenti

La lezione «Nil coalescing e ternario con gli optional» è gratuita?

Sì — il testo completo di «Nil coalescing e ternario con gli optional» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Swift Academy, passa a CoddyKit PRO. Il corso Swift Academy include 4 lezioni in totale.

Cosa imparerò in «Nil coalescing e ternario con gli optional»?

Utilizzi ?? per i valori predefiniti e concateni operatori nil-coalescing. Eserciti Swift Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Swift Academy?

Non è richiesta alcuna esperienza precedente. Swift Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Nil coalescing e ternario con gli optional»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Swift Academy?

Sì. Ogni lezione Swift Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Binding con if let e guard let
Nil coalescing e ternario con gli optional
Operatore di optional chaining ?.
Optional implicitamente unwrappati e quando evitarli

← Torna a Swift Academy