Optional / Nullable — concepte cheie și lucrul cu tipuri nullable

Ce sunt Optional și Nullable?

Optional în Swift și nullable în Kotlin — sunt instrumente lingvistice care fac null o parte explicită a sistemului de tipuri. În Swift Optional este un enum: Optional.none (nil) și Optional.some(Wrapped). În Kotlin nullable se notează cu sufixul ? în tip: String? poate fi un șir de caractere sau null.

Ambele abordări rezolvă problema fundamentală pe care Tony Hoare a numit-o „eroarea de un miliard de dolari" — null reference. Înainte de apariția tipurilor opționale, orice referință putea fi null, iar verificarea era lăsată în seama programatorului. Swift și Kotlin mută această verificare în etapa de compilare: codul care ignoră null nu se va compila.

În ciuda scopului comun, Swift și Kotlin implementează null-safety diferit. Swift folosește tipul algebric Optional cu pattern-matching complet. Kotlin încorporează nullable în sistemul de tipuri la nivel de compilator, fără a crea un tip wrapper separat.

Istoric, null reference a apărut în 1965 în limbajul ALGOL W ca o modalitate de a reprezenta absența valorii. Timp de șase decenii, null a devenit sursa a nenumărate defectări — conform cercetărilor lui Tony Hoare, între 30 și 50 la sută din erorile din codul de producție sunt legate de NullPointerException. Swift cu Optional și Kotlin cu tipurile nullable au devenit primele limbaje mainstream care au rezolvat această problemă la nivelul sistemului de tipuri, făcând null o parte explicită a contractului funcției.

Optional în Swift: sintaxa și lucrul cu tipuri opționale

În Swift Optional este un tip complet, declarat ca enum Optional<Wrapped>. Zahărul sintactic ? înlocuiește scrierea completă: Int? este echivalent cu Optional<Int>. Lucrul cu Optional include mai multe moduri de extragere a valorii.

If-let și guard-let binding

if let — extragere condiționată: dacă Optional conține o valoare, aceasta este legată de o constantă în interiorul blocului. guard let — ieșire timpurie din funcție dacă Optional este nil. guard let face codul plat, evitând if-let-urile imbricate.

Optional chaining

Optional chaining (acces sigur secvențial) prin ? permite apelarea unei metode sau proprietăți pe Optional fără unwrapping explicit. Dacă orice verigă a lanțului este nil, întregul lanț returnează nil. Aceasta scurtează codul la lucrul cu date ierarhice.

Operatorul nil-coalescing

?? (nil-coalescing) — operator care returnează valoarea Optional dacă nu este nil, altfel — valoarea implicită. Este o alternativă scurtă la if-let pentru furnizarea unei valori de rezervă.

var name: String? = "Alice"

// Legarea if-let
if let unwrapped = name {
    print("Bună, \(unwrapped)")
}

// Optional chaining
let count = name?.count

// Nil-coalescing
let display = name ?? "Invitat"

// Map pe Optional
let greeting = name.map { "Hello, \($0)" }

Nullable în Kotlin: apeluri sigure și operatorul elvis

În Kotlin nullable este parte a sistemului de tipuri, nu un tip wrapper separat. Tipul String? poate conține null, String (fără semnul întrebării) — niciodată. Compilatorul urmărește nullable prin smart cast și adnotări.

Apelul sigur ?.

?. — operatorul de apel sigur. Dacă obiectul nu este null, metoda sau proprietatea este apelată; dacă este null — se returnează null fără apel. Este analogul optional chaining din Swift, dar sintactic mai scurt.

Operatorul elvis ?:

?: — analogul Kotlin pentru nil-coalescing. Dacă expresia din stânga nu este null, este returnată; altfel — valoarea din dreapta. Operatorul elvis este adesea combinat cu ieșirea timpurie prin return sau throw.

Smart cast și operatorul !!

Smart cast — compilatorul Kotlin convertește automat nullable la non-null după verificarea null în if sau when. !! — apel forțat (force unwrap) care aruncă NullPointerException la null. Folosiți !! doar când null este o eroare.

val name: String? = "Alice"

// Apel sigur
val length = name?.length

// Operatorul elvis
val display = name ?: "Invitat"

// Smart cast după verificare
if (name != null) {
    println("Lungime: ${name.length}")
}

// Let cu lambda
name?.let { println("Bună, $it") }

// Force unwrap — doar când sunteți sigur
val forced = name!!

Optional și Nullable: diferențele cheie ale abordărilor

Deși Swift și Kotlin rezolvă aceeași sarcină, abordările lor privind null-safety diferă fundamental. Înțelegerea acestor diferențe este importantă pentru dezvoltatorii care lucrează cu ambele platforme.

Reprezentarea în sistemul de tipuri

Swift folosește enum Optional — un tip algebric standard. Kotlin încorporează nullable la nivelul sistemului de tipuri al compilatorului, fără a crea un obiect wrapper. Aceasta afectează performanța: Optional în Swift este un obiect pe heap, nullable în Kotlin este o verificare null fără alocare.

Sintaxa și expresivitatea

Sintaxa Kotlin este mai scurtă datorită operatorilor încorporați ?., ?:, !!. Swift necesită mai multă sintaxă explicită: if let, guard let, map pe Optional. Totuși, Swift oferă pattern-matching prin switch, pe care Kotlin nu îl suportă direct pentru nullable.

Pattern-uri null-safety în dezvoltarea mobilă

În dezvoltarea mobilă s-au format pattern-uri standard de lucru cu tipuri opționale care reduc cantitatea de cod șablon și măresc siguranța.

Map și flatMap pe Optional

Swift și Kotlin suportă map și flatMap pentru Optional și nullable. Dacă valoarea există — se aplică transformarea, dacă este null — se returnează null. Aceasta elimină verificările if-let imbricate.

Valori implicite prin elvis

În loc de if-let + else folosiți ?: sau ?? cu o valoare implicită. Aceasta face codul declarativ: „folosește X, dacă există, altfel Y" în loc de verificarea procedurală.

Nullable în Compose și SwiftUI

În Jetpack Compose și SwiftUI tipurile opționale gestionează afișarea: dacă starea este null — ascundem componentul, altfel îl arătăm. Aceasta corespunde principiului single source of truth.

data class UserState(
    val name: String?,
    val email: String?
)

// Smart cast în when cu variante diferite
fun greeting(state: UserState): String = when {
    state.name != null && state.email != null ->
        "${state.name} (${state.email})"
    state.name != null -> state.name
    else -> "Invitat"
}

// Compose: afișare în funcție de prezență
@Composable
fun UserProfile(name: String?) {
    name?.let {
        Text(text = it)
    } ?: Text(text = "Nu există date")
}

Pentru migrarea codului Java existent la Kotlin se recomandă utilizarea adnotărilor @Nullable și @NonNull din pachetul androidx.annotation. Compilatorul Kotlin ia în considerare aceste adnotări la interacțiunea cu Java, făcând automat tipurile corespunzătoare nullable sau non-null. Migrarea treptată cu adnotări explicite este mai sigură decât activarea globală a null-safety în proiect.

Erori tipice la lucrul cu Optional și Nullable

Null-safety reduce numărul de erori, dar nu le elimină complet. Dezvoltatorii fac adesea greșeli caracteristice la lucrul cu tipuri opționale.

• Force unwrap fără garanție — name! sau name!! fără certitudinea că valoarea nu este null duce la crash în producție. Verificați null înainte de force unwrap.
• If-let în exces — if-let-urile imbricate pentru trei sau mai multe Optional creează o piramidă (pyramid of doom). Folosiți guard let sau flatMap.
• Ignorarea nil-coalescing — verificarea explicită prin if-let cu bloc else se înlocuiește cu ?? sau ?:, ceea ce scurtează codul și îmbunătățește lizibilitatea.
• Nullable în API-uri publice — dacă funcția acceptă nullable, fiecare apel necesită verificare. Preferați non-null cu valoare implicită sau overload.