Kotlin Academy · Lektion

Förseglade resultathierarkier

Anpassade resultattyper

Lektion 3 av 413 steg

Förseglade resultathierarkier är en gratis lektion i Kotlin Academy på CoddyKit. Detta är lektion 3 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Kotlin Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Kotlin Academy innehåller totalt 4 lektioner.

Bortom det inbyggda Result

Kotlin:s Result innehåller bara ett undantag vid misslyckanden. Ofta vill ni ha rikare, typad felinformation. En hierarki av sealed class låter er modellera exakt de utfall som finns i er domän.

Ett sealed utfall

Definiera en sealed-typ med underklasser för lyckade och misslyckade resultat. Kompilatorn känner till alla fall, vilket möjliggör uttömmande hantering.

sealed class Outcome<out T> {
    data class Ok<T>(val value: T) : Outcome<T>()
    data class Err(val message: String) : Outcome<Nothing>()
}

fun main() {
    val r: Outcome<Int> = Outcome.Ok(5)
    println(r)
}

Uttömmande when

Eftersom typen är sealed behöver en when över den ingen else, och kompilatorn tvingar er att hantera varje fall.

sealed class Outcome<out T> {
    data class Ok<T>(val value: T) : Outcome<T>()
    data class Err(val message: String) : Outcome<Nothing>()
}

fun describe(o: Outcome<Int>) = when (o) {
    is Outcome.Ok -> "value " + o.value
    is Outcome.Err -> "error " + o.message
}

fun main() {
    println(describe(Outcome.Ok(9)))
    println(describe(Outcome.Err("boom")))
}

Typade felvarianter

Modellera olika typer av misslyckanden som separata underklasser, där varje klass innehåller relevanta data. Det är bättre än ett enda ogenomskinligt undantag.

sealed class Fetch<out T> {
    data class Success<T>(val data: T) : Fetch<T>()
    data class NotFound(val id: Int) : Fetch<Nothing>()
    data class Network(val code: Int) : Fetch<Nothing>()
}

fun main() {
    val r: Fetch<String> = Fetch.NotFound(42)
    println(r)
}

Hantera varje variant

En when kan reagera specifikt på varje feltyp, med full tillgång till data för varje gren.

sealed class Fetch<out T> {
    data class Success<T>(val data: T) : Fetch<T>()
    data class NotFound(val id: Int) : Fetch<Nothing>()
    data class Network(val code: Int) : Fetch<Nothing>()
}

fun handle(f: Fetch<String>) = when (f) {
    is Fetch.Success -> "data: " + f.data
    is Fetch.NotFound -> "missing id " + f.id
    is Fetch.Network -> "net error " + f.code
}

fun main() {
    println(handle(Fetch.Network(503)))
}

Nothing-tricket

Felvarianter som inte innehåller något lyckat värde använder Outcome<Nothing>. Eftersom Nothing är en subtyp till alla typer och generiken är out passar ett fel in i alla Outcome<T>.

sealed class Res<out T> {
    data class Ok<T>(val v: T) : Res<T>()
    object Empty : Res<Nothing>()
}

fun get(flag: Boolean): Res<String> =
    if (flag) Res.Ok("hi") else Res.Empty

fun main() {
    println(get(false))
}

object för tillståndslösa fall

Om en felvariant inte innehåller några data deklarerar ni den som en singleton av typen object i stället för som en klass.

sealed class Login {
    data class Success(val user: String) : Login()
    object WrongPassword : Login()
    object Locked : Login()
}

fun main() {
    val r: Login = Login.WrongPassword
    println(r === Login.WrongPassword)
}

Returnera hierarkin

Funktioner returnerar den sealed typen; anroparna måste hantera varje utfall, vilket eliminerar bortglömda felvägar.

sealed class Parsed {
    data class Num(val value: Int) : Parsed()
    data class Bad(val input: String) : Parsed()
}

fun parse(s: String): Parsed {
    val n = s.toIntOrNull()
    return if (n != null) Parsed.Num(n) else Parsed.Bad(s)
}

fun main() {
    when (val r = parse("x")) {
        is Parsed.Num -> println(r.value)
        is Parsed.Bad -> println("bad: " + r.input)
    }
}

Sealed jämfört med inbyggt Result

Använd det inbyggda Result för snabb, undantagsbaserad fångst. Använd en egen sealed-hierarki när ni behöver flera typade felvarianter med domänspecifika data och uttömmande hantering.

Utforma hierarkin

En bra design för sealed-resultat:

En variant för lyckat resultat som innehåller nyttolasten
En underklass för varje meningsfullt sätt att misslyckas
Variansen out T tillsammans med Nothing för fall som bara representerar fel

Kompilatorn som skyddsnät

Den största fördelen är att när ni senare lägger till en ny variant blir varje icke-uttömmande when ett kompileringsfel. Felet pekar ut varje plats som måste hantera den. Fel kan inte passera obemärkt.

Snabbtest

Testa er förståelse av sealed-resultathierarkier.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni byggde sealed-resultathierarkier:

Ett lyckat resultat samt typade felvarianter
Uttömmande when utan else
out T och Nothing för fall som bara representerar fel
Kompilatorn tvingar fram hantering av nya varianter

Nästa steg: funktionell felhantering med map och recover.

Gratis att börja

Lär dig Kotlin med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 51
Lektioner: 203

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Förseglade resultathierarkier” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Kotlin Academy, inklusive ”Förseglade resultathierarkier”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Kotlin Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Förseglade resultathierarkier”?

Anpassade resultattyper Ni övar på Kotlin Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Kotlin Academy?

Du behöver inga förkunskaper. Utbildningen i Kotlin Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Förseglade resultathierarkier”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Kotlin Academy-lektionen?

Ja. Varje Kotlin Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Resultattypen
runCatching
Förseglade resultathierarkier
Funktionell felhantering

← Tillbaka till Kotlin Academy