Aké sú spôsoby spracovania optionalov v jazyku Swift?

Vynucené rozbalenie:

// Používa sa !, ak ste si istí, že optional obsahuje hodnotu.
let optionalValue: String? = "ahoj"
let unwrappedValue = optionalValue! // Nebezpečné, môže spôsobiť pád, ak je hodnota nil

Voliteľné viazanie (if let, guard let):

// if let - vykoná blok kódu, ak optional nie je nil.
if let value = optionalValue {
    print(value)
}

// guard let - používa sa na skoré opustenie funkcie alebo bloku, ak je optional nil.
func processValue(_ value: String?) {
    guard let unwrappedValue = value else {
        print("Hodnota je nil")
        return
    }
    print(unwrappedValue)
}

Reťazenie voliteľných (Optional Chaining):

// Umožňuje bezpečne volať metódy, vlastnosti alebo subskripty na voliteľných hodnotách.
struct Company {
    var address: Address?
}

struct Address {
    var street: String?
}

let company: Company? = Company(address: Address(street: "Main Street"))
let street = company?.address?.street // Výsledok bude voliteľný String?

Operátor zlúčenia null (??):

// Poskytuje predvolenú hodnotu, ak je optional nil.
let name: String? = nil
let displayName = name ?? "Neznámy" // Ak je name nil, displayName bude "Neznámy"

Implicitne rozbalené voliteľné:

// Sú detegované s ! za typom. Kompilátor nevyžaduje explicitné rozbalenie, ale môže spôsobiť pád pri nil.
let implicitlyUnwrappedString: String! = "toto je reťazec"
print(implicitlyUnwrappedString.count) // Nevyžaduje ! na prístup k členom

Použitie if case let s vzorom zhodnosti:

// Pokročilejší spôsob na kontrolu enum s priradenými hodnotami, vrátane voliteľných.
enum Result {
    case success(String)
    case failure
}

let result: Result? = .success("Operácia dokončená")

if case let .success(message)? = result {
    print("Úspech so správou: \(message)")
}