Ako je implementované otváranie v Swift (voliteľné…

Voliteľné typy v Swift predstavujú typ, ktorý môže obsahovať buď hodnotu typu T (zabalena hodnota), alebo nil, čo znamená absenciu hodnoty.

Hlavné mechanizmy práce s voliteľnými:

Väzba voliteľných (if let, guard let): Bezpečné získanie hodnoty z voliteľného.
- if let: Získa hodnotu a priradí ju do dočasnej konštanty alebo premennej, ak voliteľný obsahuje hodnotu. Kód sa vykoná iba v tomto prípade.
```
let optionalString: String? = "Hello"
if let unwrappedString = optionalString {
    // unwrappedString má typ String
}
```
- guard let: Získa hodnotu. Ak je voliteľný nil, vykoná sa blok else (zvyčajne na ukončenie aktuálneho scope). Ak je hodnota úspešne získaná, je dostupná po guard v aktuálnom scope.
```
func processString(_ optionalString: String?) {
    guard let unwrappedString = optionalString else {
        return // Ukončenie funkcie
    }
    // unwrappedString typu String je dostupný tu
}
```
Lanenie voliteľných (?): Umožňuje volanie vlastností, metód a indexov na voliteľnom. Ak je voliteľný nil v ktorejkoľvek časti reťazca, celý reťazec sa preruší a výsledok má typ voliteľného obsahujúceho 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?
```

Vynútené rozbalenie (!): Nezabezpečené získanie hodnoty. Vyvolá chybu za behu (crash), ak voliteľný obsahuje nil. Mal by sa používať s veľkou opatrnosťou, iba keď je isté, že voliteľný nie je nil.

let requiredString: String! = "Must be present" // Nepriame rozbalenie voliteľného
let unwrappedString = requiredString! // Vynútené rozbalenie

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

Operátor null-coalescing (??): Poskytuje predvolenú hodnotu, ak je voliteľný nil.

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

Implicitne rozbalené voliteľné (!): Voliteľné, ktoré sa automaticky rozbalujú pri použití. Vyhlasujú sa pomocou !. Mali by sa používať, keď je zaručené, že hodnota bude pri prvom použití priradená, ale nie je nutné pri inicializácii (napr. IBOutlets). Ak je hodnota nil pri prístupe, dôjde k chybe za behu.
```
var button: UIButton! // Predpokladá sa, že bude inicializovaný v viewDidLoad
// button.setTitle("Tap me", for: .normal) // Automatické rozbalenie pri použití
```

"Smluvy" v tomto kontexte nie sú samostatným mechanizmom jazyka Swift, podobne ako zmluvy v iných jazykoch. Swift zabezpečuje bezpečnosť prostredníctvom systému typov, vrátane voliteľných a kontroly prístupu, čo pomáha jasne vyjadriť zámery a predchádzať chybám. Voliteľné slúžia ako "zmluva", ktorá naznačuje možnosť absencie hodnoty.

Ako je implementované otváranie v Swift (voliteľné, zmluvy a ďalšie mechanizmy)?