Swift Academy · Lektion

Nil-Coalescing und der ternäre Operator mit Optionals

Verwenden Sie ?? für Standardwerte und verketten Sie Nil-Coalescing-Operatoren.

Nil-Coalescing und der ternäre Operator mit Optionals ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 2 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

Der Nil-Koaleszenzoperator `??` liefert einen Standardwert, wenn ein Optional nil ist. Zusammen mit dem ternären Operator ermöglicht er eine prägnante, ausdrucksstarke Verarbeitung von Optionals.

Der ??-Operator

```swift let name: String? = nil let display = name ?? "Guest" print(display) // "Guest" let known: String? = "Alice" print(known ?? "Guest") // "Alice" ``` Ist das Optional nicht nil, wird sein aufgelöster Wert verwendet. Andernfalls wird der Standardwert verwendet.

Kurzschlussauswertung

Die rechte Seite von `??` wird nur ausgewertet, wenn die linke Seite nil ist: ```swift func expensiveDefault() -> String { print("Computing...") return "Default" } let val: String? = "Existing" let result = val ?? expensiveDefault() // expensiveDefault not called ```

?? verketten

Verketten Sie mehrere `??`-Operatoren, um mehrere Ersatzwerte auszuprobieren: ```swift let primary: String? = nil let secondary: String? = nil let fallback = "Anonymous" let user = primary ?? secondary ?? fallback print(user) // "Anonymous" ``` Die Auswertung endet beim ersten Wert, der nicht nil ist.

?? mit berechneten Eigenschaften

```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" ``` Ein übersichtliches Muster für Standardwerte in berechneten Eigenschaften.

Ternärer Operator mit Optionals

Der ternäre Ausdruck `condition ? a : b` kann mit Prüfungen auf Optionals verwendet werden: ```swift let score: Int? = 85 let label = score != nil ? "\(score!)" : "No score" ``` Aber `??` ist in der Regel übersichtlicher: ```swift let label = score.map { "\($0)" } ?? "No score" ```

Optional.map zum Transformieren

Transformieren Sie den verpackten Wert eines Optionals, ohne es aufzulösen: ```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 für optionale Verkettung

Verwenden Sie `flatMap`, wenn die Transformation selbst ein Optional zurückgibt: ```swift let str: String? = "123" let num = str.flatMap { Int($0) } // Optional(123) let bad: String? = "abc" let nil2 = bad.flatMap { Int($0) } // nil ```

??=-Zuweisungsoperator (nicht integriert)

In Swift ist `??=` nicht integriert, aber Sie können das Verhalten nachbilden: ```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() } } ```

Richtlinien zur Lesbarkeit

Wählen Sie das passende Werkzeug: • `??` – einfache Standardwerte • `if let` – wenn Sie den aufgelösten Wert in mehreren Anweisungen benötigen • `guard let` – Vorbedingung und vorzeitiger Ausstieg • `.map` / `.flatMap` – transformieren, ohne das Optional aufzulösen Vermeiden Sie das erzwungene Auflösen mit `!`, es sei denn, der Fall nil kann wirklich nicht eintreten.

Kurzer Test

Was gibt `optional ?? default` zurück, wenn `optional` `nil` ist?

Zusammenfassung

Wichtige Erkenntnisse: • `a ?? b` – gibt den Wert von `a` zurück, wenn er nicht nil ist, andernfalls `b` • Kurzschlussauswertung: `b` wird nur ausgewertet, wenn `a` nil ist • Verketten: `a ?? b ?? c` • `.map` transformiert den verpackten Wert; `.flatMap` verarbeitet Transformationen, die ein Optional zurückgeben • `??` gegenüber ternärem Operator und erzwungenem Auflösen bevorzugen Als Nächstes: optionale Verkettung mit `?.`

Häufig gestellte Fragen

Ist die Lektion „Nil-Coalescing und der ternäre Operator mit Optionals“ kostenlos?

Ja — der vollständige Text von „Nil-Coalescing und der ternäre Operator mit Optionals“ 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 „Nil-Coalescing und der ternäre Operator mit Optionals“?

Verwenden Sie ?? für Standardwerte und verketten Sie Nil-Coalescing-Operatoren. 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 2 von 4.

Wie lange dauert die Lektion „Nil-Coalescing und der ternäre Operator mit Optionals“?

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