Swift Academy · Lekcja

Nil-coalescing i operator trójargumentowy z opcjonałami

Używać ?? do wartości domyślnych i łączyć operatory nil-coalescing

Nil-coalescing i operator trójargumentowy z opcjonałami to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Swift Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Swift Academy zawiera 4 lekcji w sumie.

Wprowadzenie

Operator łączenia z nil `??` udostępnia wartość domyślną, gdy opcjonalna wartość to nil. W połączeniu z operatorem trójargumentowym pozwala zwięźle i czytelnie obsługiwać opcjonalne wartości.

Operator ??

```swift let name: String? = nil let display = name ?? "Guest" print(display) // "Guest" let known: String? = "Alice" print(known ?? "Guest") // "Alice" ``` Jeśli opcjonalna wartość nie jest nil, używana jest jej rozpakowana wartość. W przeciwnym razie używana jest wartość domyślna.

Ewaluacja skrócona

Prawa strona operatora `??` jest obliczana tylko wtedy, gdy lewa strona ma wartość nil: ```swift func expensiveDefault() -> String { print("Computing...") return "Default" } let val: String? = "Existing" let result = val ?? expensiveDefault() // expensiveDefault not called ```

Łączenie operatorów ??

Połącz wiele operatorów `??`, aby wypróbować kilka wartości zastępczych: ```swift let primary: String? = nil let secondary: String? = nil let fallback = "Anonymous" let user = primary ?? secondary ?? fallback print(user) // "Anonymous" ``` Ewaluacja kończy się na pierwszej wartości, która nie jest nil.

?? z właściwościami obliczanymi

```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" ``` To czytelny wzorzec wartości domyślnej w właściwościach obliczanych.

Operator trójargumentowy z opcjonalnymi wartościami

Operator trójargumentowy `condition ? a : b` może być używany przy sprawdzaniu opcjonalnych wartości: ```swift let score: Int? = 85 let label = score != nil ? "\(score!)" : "No score" ``` Jednak `??` jest zwykle czytelniejszy: ```swift let label = score.map { "\($0)" } ?? "No score" ```

Optional.map do przekształcania

Przekształć opakowaną wartość opcjonalną bez jej rozpakowywania: ```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 do łańcuchowania opcjonalnych wartości

Użyj `flatMap`, gdy samo przekształcenie zwraca opcjonalną wartość: ```swift let str: String? = "123" let num = str.flatMap { Int($0) } // Optional(123) let bad: String? = "abc" let nil2 = bad.flatMap { Int($0) } // nil ```

Operator przypisania ??= (niewbudowany)

Swift nie ma wbudowanego operatora `??=`, ale można go zasymulować: ```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() } } ```

Wskazówki dotyczące czytelności

Wybierz właściwe narzędzie: • `??` — proste wartości domyślne • `if let` — gdy potrzebujesz rozpakowanej wartości w wielu instrukcjach • `guard let` — warunek wstępny i szybkie zakończenie działania • `.map` / `.flatMap` — przekształcanie bez rozpakowywania Unikaj wymuszonego rozpakowywania za pomocą `!`, chyba że przypadek nil rzeczywiście nie może wystąpić.

Szybkie sprawdzenie

Co zwraca wyrażenie `optional ?? default`, gdy `optional` ma wartość `nil`?

Podsumowanie

Najważniejsze informacje: • `a ?? b` — zwraca wartość `a`, jeśli nie jest nil, a w przeciwnym razie `b` • Działa z ewaluacją skróconą: `b` jest obliczane tylko wtedy, gdy `a` ma wartość nil • Łącz operatory: `a ?? b ?? c` • `.map` przekształca opakowaną wartość; `.flatMap` obsługuje przekształcenia zwracające Optional • Preferuj `??` zamiast operatora trójargumentowego z wymuszonym rozpakowywaniem Następnie: łańcuchowanie opcjonalne z użyciem `?.`

Często zadawane pytania

Czy lekcja „Nil-coalescing i operator trójargumentowy z opcjonałami” jest bezpłatna?

Tak — pełny tekst „Nil-coalescing i operator trójargumentowy z opcjonałami” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Swift Academy, przejdź na CoddyKit PRO. Kurs Swift Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Nil-coalescing i operator trójargumentowy z opcjonałami”?

Używać ?? do wartości domyślnych i łączyć operatory nil-coalescing Ćwiczysz Swift Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Swift Academy?

Nie wymagamy żadnego doświadczenia. Swift Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Nil-coalescing i operator trójargumentowy z opcjonałami”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Swift Academy?

Tak. Każda lekcja Swift Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Wiązanie if let i guard let
Nil-coalescing i operator trójargumentowy z opcjonałami
Operator optional chaining ?.
Opcjonały rozwijane niejawnie i sytuacje, w których należy ich unikać

← Powrót do Swift Academy