Optional / Nullable — klíčové pojmy a práce s nullable typy

Co jsou Optional a Nullable?

Optional ve Swift a nullable v Kotlin — jsou jazykové prostředky, které činí null explicitní součástí typového systému. Ve Swift je Optional enum: Optional.none (nil) a Optional.some(Wrapped). V Kotlin se nullable označuje příponou ? v typu: String? může být řetězec nebo null.

Oba přístupy řeší zásadní problém, který Tony Hoare nazval „chybou za miliardu dolarů" — null reference. Před příchodem volitelných typů mohla být jakákoli reference null a kontrola byla ponechána na programátorovi. Swift a Kotlin přesouvají tuto kontrolu do fáze kompilace: kód, který ignoruje null, se nezkompiluje.

Navzdory společnému cíli implementují Swift a Kotlin null-safety odlišně. Swift používá algebraický typ Optional s plným pattern-matching. Kotlin vkládá nullable do typového systému na úrovni kompilátoru, aniž by vytvářel samostatný typ wrapper.

Historicky se null reference objevil v roce 1965 v jazyce ALGOL W jako způsob reprezentace absence hodnoty. Během šesti desetiletí se null stal zdrojem nespočtu selhání — podle výzkumu Tonyho Hoarea je 30 až 50 procent chyb v produkčním kódu spojeno s NullPointerException. Swift s Optional a Kotlin s nullable typy se staly prvními mainstreamovými jazyky, které tento problém vyřešily na úrovni typového systému, čímž se null stal explicitní součástí kontraktu funkce.

Optional ve Swift: syntaxe a práce s volitelnými typy

Ve Swift je Optional plnohodnotný typ, deklarovaný jako enum Optional<Wrapped>. Syntaktický cukr ? nahrazuje plný zápis: Int? je ekvivalentní Optional<Int>. Práce s Optional zahrnuje několik způsobů extrakce hodnoty.

If-let a guard-let binding

if let — podmíněná extrakce: pokud Optional obsahuje hodnotu, je svázána s konstantou uvnitř bloku. guard let — předčasný odchod z funkce, pokud je Optional roven nil. guard let činí kód plochým, čímž se vyhýbá vnořeným if-let.

Optional chaining

Optional chaining (bezpečný sekvenční přístup) přes ? umožňuje volat metodu nebo vlastnost na Optional bez explicitního unwrappingu. Pokud je jakýkoli článek řetězce nil, celý řetězec vrátí nil. To zkracuje kód při práci s hierarchickými daty.

Operátor nil-coalescing

?? (nil-coalescing) — operátor, který vrací hodnotu Optional, pokud není nil, jinak výchozí hodnotu. Je to krátká alternativa k if-let pro poskytnutí záložní hodnoty.

var name: String? = "Alice"

// If-let vázání
if let unwrapped = name {
    print("Ahoj, \(unwrapped)")
}

// Optional chaining
let count = name?.count

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

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

Nullable v Kotlin: bezpečná volání a operátor elvis

V Kotlin je nullable součástí typového systému, nikoli samostatný typ wrapper. Typ String? může obsahovat null, String (bez otazníku) — nikdy. Kompilátor sleduje nullable pomocí smart cast a anotací.

Bezpečné volání ?.

?. — operátor bezpečného volání. Pokud objekt není null, je metoda nebo vlastnost volána; pokud je null — vrací se null bez volání. Je to analogie optional chaining ve Swift, ale syntakticky kratší.

Operátor elvis ?:

?: — Kotlin obdoba nil-coalescing. Pokud výraz vlevo není null, je vrácen; jinak — hodnota vpravo. Operátor elvis se často kombinuje s předčasným odchodem pomocí return nebo throw.

Smart cast a operátor !!

Smart cast — kompilátor Kotlin automaticky převádí nullable na non-null po kontrole null v if nebo when. !! — vynucené volání (force unwrap), které vyvolá NullPointerException při null. Používejte !! pouze když je null chyba.

val name: String? = "Alice"

// Bezpečné volání
val length = name?.length

// Operátor elvis
val display = name ?: "Host"

// Smart cast po kontrole
if (name != null) {
    println("Délka: ${name.length}")
}

// Let s lambdou
name?.let { println("Ahoj, $it") }

// Force unwrap — jen když jste si jisti
val forced = name!!

Optional a Nullable: klíčové rozdíly přístupů

Přestože Swift a Kotlin řeší stejný úkol, jejich přístupy k null-safety se zásadně liší. Porozumění těmto rozdílům je důležité pro vývojáře pracující s oběma platformami.

Reprezentace v typovém systému

Swift používá enum Optional — standardní algebraický typ. Kotlin vkládá nullable na úrovni typového systému kompilátoru, aniž by vytvářel objekt wrapper. To ovlivňuje výkon: Optional ve Swift je objekt na haldě, nullable v Kotlin je kontrola null bez alokace.

Syntaxe a expresivita

Syntaxe Kotlin je kratší díky vestavěným operátorům ?., ?:, !!. Swift vyžaduje více explicitní syntaxe: if let, guard let, map na Optional. Swift však poskytuje pattern-matching přes switch, což Kotlin přímo nepodporuje pro nullable.

Vzory null-safety v mobilním vývoji

V mobilním vývoji se vytvořily standardní vzory práce s volitelnými typy, které snižují množství šablonového kódu a zvyšují bezpečnost.

Map a flatMap na Optional

Swift a Kotlin podporují map a flatMap pro Optional a nullable. Pokud hodnota existuje — použije se transformace, pokud je null — vrátí se null. To eliminuje vnořené kontroly if-let.

Výchozí hodnoty pomocí elvis

Místo if-let + else použijte ?: nebo ?? s výchozí hodnotou. To činí kód deklarativním: „použij X, pokud existuje, jinak Y" místo procedurální kontroly.

Nullable v Compose a SwiftUI

V Jetpack Compose a SwiftUI spravují volitelné typy zobrazení: pokud je stav null — skryjeme komponentu, jinak zobrazíme. To odpovídá principu single source of truth.

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

// Smart cast v when s různými variantami
fun greeting(state: UserState): String = when {
    state.name != null && state.email != null ->
        "${state.name} (${state.email})"
    state.name != null -> state.name
    else -> "Host"
}

// Compose: zobrazení podle přítomnosti
@Composable
fun UserProfile(name: String?) {
    name?.let {
        Text(text = it)
    } ?: Text(text = "Žádná data")
}

Pro migraci existujícího Java kódu na Kotlin se doporučuje používat anotace @Nullable a @NonNull z balíčku androidx.annotation. Kotlin kompilátor tyto anotace zohledňuje při interakci s Java, čímž automaticky činí odpovídající typy nullable nebo non-null. Postupná migrace s explicitními anotacemi je bezpečnější než globální zapnutí null-safety v projektu.

Typické chyby při práci s Optional a Nullable

Null-safety snižuje počet chyb, ale zcela je neodstraňuje. Vývojáři často dělají charakteristické chyby při práci s volitelnými typy.

• Force unwrap bez záruky — name! nebo name!! bez jistoty, že hodnota není null, vede k pádu v produkci. Zkontrolujte null před force unwrap.
• Nadměrné if-let — vnořené if-let pro tři a více Optional vytváří pyramidu (pyramid of doom). Použijte guard let nebo flatMap.
• Ignorování nil-coalescing — explicitní kontrola pomocí if-let s blokem else se nahrazuje ?? nebo ?:, což zkracuje kód a zlepšuje čitelnost.
• Nullable ve veřejných API — pokud funkce přijímá nullable, každé volání vyžaduje kontrolu. Preferujte non-null s výchozí hodnotou nebo overload.