Jaké jsou způsoby zpracování optionalů v jazyce Swift?

Vynucené rozbalení:

// Používá se !, pokud jste si jisti, že optional obsahuje hodnotu.
let optionalValue: String? = "ahoj"
let unwrappedValue = optionalValue! // Nebezpečné, může způsobit pád, pokud je hodnota nil

Volitelné vázání (if let, guard let):

// if let - provede blok kódu, pokud optional není nil.
if let value = optionalValue {
    print(value)
}

// guard let - používá se k časnému opuštění funkce nebo bloku, pokud je optional nil.
func processValue(_ value: String?) {
    guard let unwrappedValue = value else {
        print("Hodnota je nil")
        return
    }
    print(unwrappedValue)
}

Řetězení volitelných (Optional Chaining):

// Umožňuje bezpečně volat metody, vlastnosti nebo subskripty na volitelný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ýsledek bude volitelný String?

Operátor sloučení null (??):

// Poskytuje výchozí hodnotu, pokud je optional nil.
let name: String? = nil
let displayName = name ?? "Anonymní" // Pokud je name nil, displayName bude "Anonymní"

Implicitně rozbalené volitelné:

// Jsou detekovány s ! za typem. Kompilátor nevyžaduje explicitní rozbalení, ale může vést k pádu při nil.
let implicitlyUnwrappedString: String! = "toto je řetězec"
print(implicitlyUnwrappedString.count) // Nevyžaduje ! pro přístup ke členům

Použití if case let s vzorem shody:

// Pokročilejší způsob kontroly enum s přiřazenými hodnotami, včetně volitelných.
enum Result {
    case success(String)
    case failure
}

let result: Result? = .success("Operace dokončena")

if case let .success(message)? = result {
    print("Úspěch se zprávou: \(message)")
}