Kotlin Academy · leksjon

Funksjonell feilhåndtering

Map og gjenopprett

Leksjon 4 av 413 trinn

Funksjonell feilhåndtering er en gratis leksjon i Kotlin Academy på CoddyKit. Dette er leksjon 4 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Kotlin Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Kotlin Academy inneholder totalt 4 leksjoner.

Feil som dataflyt

Funksjonell feilhåndtering behandler feil som verdier De kan transformere, kjede og gjenopprette fra – akkurat som De transformerer vellykkede verdier. Det innebygde Result tilbyr operatorer for nettopp dette.

map

map transformer en vellykket verdi og lar en feil være urørt, slik at den videreføres uendret.

fun main() {
    val r = Result.success(5).map { it * 2 }
    println(r.getOrNull())
    val f = Result.failure<Int>(Exception("x")).map { it * 2 }
    println(f.getOrNull())
}

mapCatching

Hvis selve transformasjonen kan kaste et unntak, fanger mapCatching dette unntaket inn i resultatet i stedet for å la det slippe ut.

fun main() {
    val r = Result.success("10").mapCatching { it.toInt() }
    println(r.getOrNull())
    val bad = Result.success("oops").mapCatching { it.toInt() }
    println(bad.isFailure)
}

recover

recover gjør en feil om til en suksess igjen ved å beregne en verdi ut fra unntaket. En suksess sendes videre uendret.

fun main() {
    val r = Result.failure<Int>(Exception("down")).recover { 0 }
    println(r.getOrNull())
    val ok = Result.success(7).recover { 0 }
    println(ok.getOrNull())
}

recoverCatching

Når gjenopprettingslogikken også kan mislykkes, pakker recoverCatching forsøket inn og sørger for at alt forblir et resultat.

fun main() {
    val r = Result.failure<Int>(Exception()).recoverCatching {
        "5".toInt()
    }
    println(r.getOrNull())
}

onSuccess og onFailure

Disse utfører sideeffekter uten å endre resultatet, og returnerer det slik at kjedingen kan fortsette. Dette er svært nyttig for logging.

fun main() {
    runCatching { "3".toInt() }
        .onSuccess { println("ok " + it) }
        .onFailure { println("fail " + it.message) }
        .also { println("done") }
}

Kjede en pipeline

Operatorer kan settes sammen til en ryddig pipeline: fang opp, transformer og gjenopprett – alt uten nestede try/catch-blokker.

fun main() {
    val result = runCatching { "21".toInt() }
        .map { it * 2 }
        .recover { -1 }
        .getOrThrow()
    println(result)
}

fold til en endelig verdi

Avslutt en pipeline med fold for å samle begge grenene til én konkret verdi, for eksempel en melding som vises til brukeren.

fun main() {
    val msg = runCatching { "x".toInt() }
        .map { it + 1 }
        .fold(
            onSuccess = { "result: " + it },
            onFailure = { "failed: " + it.message }
        )
    println(msg)
}

Mappe over en egendefinert type

De kan gi Deres egen sealed result-type samme brukervennlighet ved å skrive utvidelsesfunksjoner som map.

sealed class Res<out T> {
    data class Ok<T>(val v: T) : Res<T>()
    data class Err(val msg: String) : Res<Nothing>()
}

fun <T, R> Res<T>.map(f: (T) -> R): Res<R> = when (this) {
    is Res.Ok -> Res.Ok(f(v))
    is Res.Err -> this
}

fun main() {
    val r = Res.Ok(4).map { it * 3 }
    println(r)
}

Hvorfor funksjonell stil

Funksjonell feilhåndtering gjør normalflyten lett å lese, samtidig som feil flyter deklarativt gjennom koden. Det finnes ingen spredte try/catch-blokker, og typesystemet følger feilen fra ende til annen.

Sett alt sammen

De har nå et komplett verktøysett:

map / mapCatching til å transformere
recover / recoverCatching til å gjenopprette
onSuccess / onFailure for sideeffekter
fold for å avslutte

Hurtigsjekk

Test forståelsen Deres av funksjonell feilhåndtering.

Besvar den i den interaktive leksjonen

Oppsummering

De har lært funksjonell feilhåndtering:

Transformer med map / mapCatching
Gjenopprett med recover / recoverCatching
Observer med onSuccess / onFailure
Avslutt med fold

Dette avslutter kurset om Result og feilmodellering.

Gratis å komme i gang

Lær deg Kotlin med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 51
Leksjoner: 203

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Funksjonell feilhåndtering» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Kotlin Academy, inkludert «Funksjonell feilhåndtering», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Kotlin Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Funksjonell feilhåndtering»?

Map og gjenopprett Du øver på Kotlin Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Kotlin Academy?

Ingen tidligere erfaring er nødvendig. Kotlin Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 4 av 4.

Hvor lang tid tar leksjonen «Funksjonell feilhåndtering»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Kotlin Academy-leksjonen?

Ja. Alle Kotlin Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Kotlin Academy