Wiązanie if let i guard let

Opcjonalne wartości reprezentują wartości, które mogą istnieć, ale nie muszą. Bezpieczne rozpakowywanie za pomocą `if let` i `guard let` jest podstawą kodu Swift odpornego na awarie.

```swift var name: String? = "Alice" // has a value var age: Int? = nil // no value ``` Optional opakowuje wartość jako `.some(value)` albo `.none`. Przed użyciem trzeba ją rozpakować.

```swift if let name = name { print("Hello, \(name)!") // name is String here } else { print("No name provided") } ``` Wewnątrz bloku `if` zmienna `name` ma nieopcjonalny typ `String`.

Od wersji Swift 5.7 można ponownie używać tej samej nazwy zmiennej: ```swift if let name { print("Hello, \(name)!") } ``` To krótsze i czytelniejsze rozwiązanie — nie trzeba zapisywać `let name = name`.

`guard let` rozpakowuje wartość i kończy działanie wcześniej, jeśli jest ona równa nil: ```swift func greet(_ name: String?) { guard let name else { return } print("Hello, \(name)!") } ``` Po instrukcji `guard` jest zagwarantowane, że `name` nie ma wartości nil przez resztę funkcji.

Rozpakuj wiele opcjonalnych wartości w jednej instrukcji: ```swift if let first = firstName, let last = lastName { print("\(first) \(last)") } guard let id = userId, let token = authToken else { return } ``` Wszystkie wiązania muszą się powieść, aby wykonało się ciało instrukcji.

Połącz rozpakowywanie z warunkiem: ```swift if let score = rawScore, score >= 60 { print("Passed with \(score)") } ``` Wiązanie i warunek są oceniane razem — to czytelniejsze niż zagnieżdżona instrukcja `if`.

Użyj `if let`, gdy obie gałęzie potrzebują tej wartości. Użyj `guard let`, aby sprawdzić warunki wstępne i zakończyć działanie wcześniej: ```swift // if let: handle both cases if let data = response.data { process(data) } else { showError() } // guard: ensure requirements are met guard let data = response.data else { showError(); return } process(data) ```

Głęboko zagnieżdżone `if let` („piramida zagłady”) jest trudniejsze do odczytania: ```swift if let a = aOpt { if let b = bOpt { if let c = cOpt { process(a, b, c) } } } ``` Zrefaktoryzuj kod za pomocą `guard`: ```swift guard let a = aOpt, let b = bOpt, let c = cOpt else { return } process(a, b, c) ```

Użyj `!= nil`, gdy trzeba tylko sprawdzić, czy wartość istnieje: ```swift if token != nil { showLoggedInUI() } ``` Jeśli potrzebujesz również rozpakowanej wartości, preferuj jednak `if let`.

Najważniejsze informacje: • `if let x = optional` — bezpieczne przejście do kontekstu, w którym wartość nie jest nil • `guard let x = optional else { return }` — szybkie zakończenie działania w przypadku niepowodzenia • Łącz wiele wiązań za pomocą przecinków • `guard let` pozwala uniknąć głęboko zagnieżdżonych piramid • Swift 5.7+: `if let x` (skrócona forma z tą samą nazwą) Następnie: operator łączenia z nil i operator ??.