Jak je v Swiftu implementováno otevírání (volitelné…

Volitelné typy v Swift představují typ, který může obsahovat buď hodnotu typu T (zabalena hodnota), nebo nil, což znamená absenci hodnoty.

Hlavní mechanismy práce s volitelnými:

Vazba volitelných (if let, guard let): Bezpečné získání hodnoty z volitelného.
- if let: Získá hodnotu a přiřadí ji do dočasné konstanty nebo proměnné, pokud volitelný obsahuje hodnotu. Kód se vykoná pouze v tomto případě.
```
let optionalString: String? = "Hello"
if let unwrappedString = optionalString {
    // unwrappedString má typ String
}
```
- guard let: Získá hodnotu. Pokud je volitelný nil, provede se blok else (obvykle pro ukončení aktuálního scope). Pokud je hodnota úspěšně získána, je dostupná po guard v aktuálním scope.
```
func processString(_ optionalString: String?) {
    guard let unwrappedString = optionalString else {
        return // Ukončení funkce
    }
    // unwrappedString typu String je dostupný zde
}
```
Řetězení volitelných (?): Umožňuje volání vlastností, metod a indexů na volitelném. Pokud je volitelný nil v jakémkoli bodě řetězce, celý řetězec se přeruší a výsledek má typ volitelného obsahujícího nil.
```
class Person {
    var job: Job?
}

class Job {
    var salary: Double?
}

let person: Person? = Person()
person?.job = Job()
let salary = person?.job?.salary // salary má typ Double?
```

Vynucené rozbalení (!): Nezabezpečené získání hodnoty. Vyvolá chybu za běhu (crash), pokud volitelný obsahuje nil. Mělo by se používat s velkou opatrností, pouze když je jisté, že volitelný není nil.

let requiredString: String! = "Must be present" // Implicitně rozbalený volitelný
let unwrappedString = requiredString! // Vynucené rozbalení

let dangerousOptional: String? = nil
// let crash = dangerousOptional! // Vyvolá chybu

Operátor null-coalescing (??): Poskytuje výchozí hodnotu, pokud je volitelný nil.

let optionalValue: Int? = nil
let definiteValue = optionalValue ?? 0 // definiteValue bude 0

Implicitně rozbalené volitelné (!): Volitelné, které se automaticky rozbalují při použití. Deklarují se pomocí !. Mělo by se používat, když je zaručeno, že hodnota bude při prvním použití přiřazena, ale není nutné při inicializaci (například IBOutlets). Pokud je hodnota nil při přístupu, dojde k chybě za běhu.
```
var button: UIButton! // Předpokládá se, že bude inicializováno v viewDidLoad
// button.setTitle("Tap me", for: .normal) // Automatické rozbalení při použití
```

"Smlouvy" v tomto kontextu nejsou samostatným mechanismem jazyka Swift, podobně jako smlouvy v jiných jazycích. Swift zajišťuje bezpečnost prostřednictvím systému typů, včetně volitelných a kontroly přístupu, což pomáhá explicitně vyjadřovat záměry a předcházet chybám. Volitelné fungují jako "smlouva", která ukazuje na možnost absence hodnoty.

Jak je v Swiftu implementováno otevírání (volitelné, smlouvy a další mechanismy)?