Care sunt modalitățile de tratare a optionalilor în Swift?

Dezambalare forțată:

// Se folosește ! dacă e sigur că optionalul conține o valoare.
let optionalValue: String? = "salut"
let unwrappedValue = optionalValue! // Periculos, poate cauza crash dacă valoarea este nil

Legarea opțională (if let, guard let):

// if let - execută blocul de cod dacă optionalul nu este nil.
if let value = optionalValue {
    print(value)
}

// guard let - folosit pentru a ieși devreme din funcție sau bloc dacă optionalul este nil.
func processValue(_ value: String?) {
    guard let unwrappedValue = value else {
        print("Valoare nil")
        return
    }
    print(unwrappedValue)
}

Împâslire opțională:

// Permite apelarea sigură a metodelor, proprietăților sau subscripturilor pe valori opționale.
struct Company {
    var address: Address?
}

struct Address {
    var street: String?
}

let company: Company? = Company(address: Address(street: "Main Street"))
let street = company?.address?.street // Rezultatul va fi un String opțional?

Operatorul de coalescență nil (??):

// Oferă o valoare implicită dacă optionalul este nil.
let name: String? = nil
let displayName = name ?? "Anonim" // Dacă name este nil, displayName va fi "Anonim"

Optional implicite deconspirate:

// Sunt detectate cu ! după tip. Compilatorul nu necesită deconspirare explicită, dar poate duce la crash dacă nil.
let implicitlyUnwrappedString: String! = "aceasta este o șir"
print(implicitlyUnwrappedString.count) // Nu necesită ! pentru acces la membri

Utilizarea if case let cu potrivire de pattern-uri:

// Metodă mai avansată pentru verificarea enumurilor cu valori asociate, inclusiv opționale.
enum Result {
    case success(String)
    case failure
}

let result: Result? = .success("Operație finalizată")

if case let .success(message)? = result {
    print("Succes cu mesaj: \(message)")
}