Swift Academy · Lektion

Optional Chaining ?. Operator

Rufen Sie Methoden auf und greifen Sie auf Eigenschaften von Optionals zu, ohne Abstürze zu verursachen.

Optional Chaining ?. Operator ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Swift Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Willkommen

Mit optionaler Verkettung können Sie Methoden aufrufen, auf Eigenschaften zugreifen und Subscripts über eine Kette von Optionals verwenden – sicher. Ist ein beliebiges Glied der Kette nil, gibt der gesamte Ausdruck nil zurück, ohne einen Absturz zu verursachen.

Der ?. Operator

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

Mehrere Ebenen verketten

Ketten können beliebig tief sein: ```swift struct Company { var ceo: Person? } let company = Company(ceo: alice) let city = company.ceo?.address?.city print(city ?? "Unknown") // "Istanbul" ``` Wenn `ceo` oder `address` nil ist, wird `city` zu nil.

Methoden über Verkettung aufrufen

Methoden können ebenfalls über optionale Verkettung aufgerufen werden: ```swift var name: String? = "alice" let upper = name?.uppercased() // Optional("ALICE") name = nil let upper2 = name?.uppercased() // nil ``` Der Rückgabetyp wird optional: `String` wird zu `String?`.

Subscripts über Verkettung

```swift var dict: [String: [Int]]? = ["scores": [10, 20, 30]] let first = dict?["scores"]?[0] // Optional(10) dict = nil let none = dict?["scores"]?[0] // nil ``` Subscripts funktionieren in einer Kette genauso wie Eigenschaften und Methoden.

Verkettung erzeugt ein Optional

Auch wenn das Endergebnis nicht optional ist, verpackt die Verkettung es in ein Optional: ```swift struct Cat { var lives: Int = 9 } var cat: Cat? = Cat() let lives = cat?.lives // Int? not Int ``` Lösen Sie es je nach Bedarf mit `??`, `if let` oder `guard let` auf.

Werte durch Verkettung setzen

Sie können Eigenschaften durch optionale Verkettungen setzen: ```swift var profile: UserProfile? = UserProfile() profile?.name = "Alice" ``` Wenn `profile` nil ist, wird die Zuweisung stillschweigend ignoriert (es kommt nicht zum Absturz).

Void-Methoden per Verkettung aufrufen

```swift var manager: SoundManager? manager?.play() // silently ignored if nil ``` Der Aufruf gibt `Void?` zurück — `()` bei einem Wert ungleich nil und `nil`, wenn das Optional nil war. Sie können das Ergebnis prüfen, um festzustellen, ob der Aufruf ausgeführt wurde.

Optionale Verkettung vs. erzwungenes Entpacken

```swift // Forced unwrap — crashes if nil: let city = alice.address!.city // Optional chaining — safe: let city = alice.address?.city ``` Bevorzugen Sie immer die optionale Verkettung. Verwenden Sie `!` nur, wenn Sie sicher sind, dass nil nicht auftreten kann.

Mit ?? Standardwerte festlegen

Verketten Sie `??` mit einer optionalen Verkettung, um übersichtliche Standardwerte festzulegen: ```swift let displayCity = user.profile?.address?.city ?? "Unknown City" let count = database?.records?.count ?? 0 ``` Die gesamte Verkettung ergibt entweder einen Wert oder greift auf den Standardwert zurück.

Kurzer Test

Wenn ein beliebiges Glied einer optionalen Verkettung `nil` ist, was gibt der gesamte Ausdruck zurück?

Zusammenfassung

Wichtigste Erkenntnisse: • `?.` greift sicher auf Eigenschaften und Subscripts zu und ruft Methoden von Optionals auf • Wenn ein beliebiges Glied nil ist, gibt die gesamte Verkettung nil zurück • Der Ergebnistyp ist immer optional (auch wenn der letzte Wert normalerweise nicht optional ist) • Kombinieren Sie `?.` mit `??` für übersichtliche Muster aus sicherem Zugriff und Standardwerten • Bevorzugen Sie `?.` gegenüber `!`, um Abstürze zu vermeiden Als Nächstes: implizit entpackte Optionals.

Häufig gestellte Fragen

Ist die Lektion „Optional Chaining ?. Operator“ kostenlos?

Ja — der vollständige Text von „Optional Chaining ?. Operator“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Swift Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Optional Chaining ?. Operator“?

Rufen Sie Methoden auf und greifen Sie auf Eigenschaften von Optionals zu, ohne Abstürze zu verursachen. Du übst Swift Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Swift Academy zu starten?

Keine Vorkenntnisse erforderlich. Swift Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Optional Chaining ?. Operator“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Swift Academy-Lektion Code schreiben und ausführen?

Ja. Jede Swift Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

if-let- und guard-let-Bindung
Nil-Coalescing und der ternäre Operator mit Optionals
Optional Chaining ?. Operator
Implizit entpackte Optionals und wann Sie sie vermeiden sollten

← Zurück zu Swift Academy