Swift Academy · Lezione

Operatore di optional chaining ?.

Chiami metodi e acceda alle proprietà degli optional senza causare arresti anomali.

Operatore di optional chaining ?. è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 3 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'optional chaining consente di chiamare metodi, accedere a proprietà e usare subscript attraverso una catena di optional, in sicurezza. Se un qualsiasi collegamento della catena è nil, l'intera espressione restituisce nil senza causare arresti anomali.

L'operatore ?.

```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 ```

Catene a più livelli

Le catene possono avere una profondità arbitraria: ```swift struct Company { var ceo: Person? } let company = Company(ceo: alice) let city = company.ceo?.address?.city print(city ?? "Unknown") // "Istanbul" ``` Se `ceo` o `address` è nil, `city` diventa nil.

Chiamare metodi tramite il chaining

È possibile chiamare anche i metodi tramite l'optional chaining: ```swift var name: String? = "alice" let upper = name?.uppercased() // Optional("ALICE") name = nil let upper2 = name?.uppercased() // nil ``` Il tipo restituito diventa optional: `String` diventa `String?`.

Subscript tramite il chaining

```swift var dict: [String: [Int]]? = ["scores": [10, 20, 30]] let first = dict?["scores"]?[0] // Optional(10) dict = nil let none = dict?["scores"]?[0] // nil ``` I subscript funzionano allo stesso modo delle proprietà e dei metodi all'interno di una catena.

Il chaining produce un optional

Anche se il risultato finale non è un optional, il chaining lo incapsula in un Optional: ```swift struct Cat { var lives: Int = 9 } var cat: Cat? = Cat() let lives = cat?.lives // Int? not Int ``` Esegua l'unwrapping con `??`, `if let` o `guard let` secondo necessità.

Impostazione dei valori tramite concatenamento

È possibile impostare le proprietà tramite concatenamenti opzionali: ```swift var profile: UserProfile? = UserProfile() profile?.name = "Alice" ``` Se `profile` è nil, l'assegnazione viene ignorata senza errori (nessun arresto anomalo).

Chiamata di metodi Void tramite concatenamento

```swift var manager: SoundManager? manager?.play() // silently ignored if nil ``` La chiamata restituisce `Void?` — `()` se il valore non è nil, `nil` se l'opzionale era nil. È possibile verificare il risultato per sapere se la chiamata è stata eseguita.

Concatenamento opzionale e force unwrap

```swift // Forced unwrap — crashes if nil: let city = alice.address!.city // Optional chaining — safe: let city = alice.address?.city ``` Preferisca sempre il concatenamento opzionale. Utilizzi `!` solo quando è certo che nil non possa verificarsi.

Combinazione con ?? per i valori predefiniti

È possibile concatenare `??` dopo il concatenamento opzionale per definire valori predefiniti in modo chiaro: ```swift let displayCity = user.profile?.address?.city ?? "Unknown City" let count = database?.records?.count ?? 0 ``` L'intera catena restituisce un valore oppure utilizza il valore predefinito.

Verifica rapida

Se un qualsiasi collegamento di un concatenamento opzionale è `nil`, che cosa restituisce l'intera espressione?

Riepilogo

Concetti chiave: • `?.` accede in modo sicuro alle proprietà, chiama i metodi e utilizza i pedici degli opzionali • Se un qualsiasi collegamento è nil, l'intera catena restituisce nil • Il tipo del risultato è sempre opzionale (anche se il valore finale normalmente non lo è) • Combini `?.` con `??` per creare schemi chiari di accesso sicuro con valore predefinito • Preferisca `?.` a `!` per evitare arresti anomali Successivo: opzionali implicitamente estratti.

Domande Frequenti

La lezione «Operatore di optional chaining ?. » è gratuita?

Sì — il testo completo di «Operatore di optional chaining ?. » è 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 «Operatore di optional chaining ?. »?

Chiami metodi e acceda alle proprietà degli optional senza causare arresti anomali. 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 3 di 4.

Quanto tempo richiede la lezione «Operatore di optional chaining ?. »?

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