Cum se implementează deschiderea în Swift (opționale…

Opționalele în Swift reprezintă un tip care poate conține fie o valoare de tip T (valoare încapsulată), fie nil, ceea ce indică absența valorii.

Mecanismele principale pentru lucrul cu opționale:

Legarea opțională (if let, guard let): Extracția sigură a valorii dintr-un opțional.
- if let: Extrage valoarea și o atribuie unei constante sau variabile temporare dacă opționalul conține o valoare. Blocul de cod se execută doar în acest caz.
```
let optionalString: String? = "Hello"
if let unwrappedString = optionalString {
    // unwrappedString are tipul String
}
```
- guard let: Extrage valoarea. Dacă opționalul este nil, se execută blocul else (de obicei pentru a ieși din scopul curent). Dacă valoarea este extrasă cu succes, este disponibilă după guard în scopul curent.
```
func processString(_ optionalString: String?) {
    guard let unwrappedString = optionalString else {
        return // Ieșire din funcție
    }
    // unwrappedString de tip String este disponibil aici
}
```
Încâlcirea opțională (?): Permite apelarea proprietăților, metodelor și indicilor pe un opțional. Dacă în orice etapă a lanțului opționalul este nil, întreg lanțul se întrerupe, iar rezultatul are tipul opțional care conține nil.
```
class Person {
    var job: Job?
}

class Job {
    var salary: Double?
}

let person: Person? = Person()
person?.job = Job()
let salary = person?.job?.salary // salary are tipul Double?
```

Dezambalare forțată (!): Extracție nesigură a valorii. Duce la o eroare de execuție (crash) dacă opționalul conține nil. Trebuie folosit cu mare precauție, doar când se știe sigur că opționalul nu este nil.

let requiredString: String! = "Must be present" // Opțional implicit
let unwrappedString = requiredString! // Dezambalare forțată

let dangerousOptional: String? = nil
// let crash = dangerousOptional! // Va cauza o eroare

Operatorul de coalescență nulă (??): Oferă o valoare implicită dacă opționalul este nil.

let optionalValue: Int? = nil
let definiteValue = optionalValue ?? 0 // definiteValue va fi 0

Opționale implicite dezambalate (!): Opționale care sunt dezambalate automat la utilizare. Sunt declarate cu !. Trebuie folosite când se garantează că valoarea va fi atribuită înainte de prima utilizare, dar nu neapărat la inițializare (de exemplu, IBOutlets). La acces, dacă valoarea este nil, apare o eroare de execuție.
```
var button: UIButton! // Se presupune că va fi inițializat în viewDidLoad
// button.setTitle("Tap me", for: .normal) // Dezambalare automată la utilizare
```

"Contractele" în acest context nu sunt un mecanism de limbaj separat în Swift, similar cu contractele în alte limbaje. Swift asigură siguranța printr-un sistem de tipuri, inclusiv opționale și controlul accesului, ceea ce ajută la exprimarea clară a intențiilor și prevenirea erorilor. Opționalele servesc drept "contract" care indică posibilitatea lipsei valorii.

Cum se implementează deschiderea în Swift (opționale, contracte și alte mecanisme)?