Kotlin Academy · Lektion

runCatching och Result<T>

Använd runCatching för att kapsla in exception i Result och behandla dem funktionellt.

Lektion 3 av 413 steg

runCatching och Result<T> ä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.

Result<T> i korthet

Result<T> är Kโotlin:s omslag för resultatet av en operation: antingen ett lyckat resultat med ett värde av typen T eller ett misslyckat resultat med en Throwable.

Grunderna i runCatching

runCatching { ... } kör blocket och omsluter resultatet i ett Result.

fun main() {
    val good = runCatching { 10 / 2 }
    val bad  = runCatching { 10 / 0 }
    println("good isSuccess = ${good.isSuccess}")
    println("bad isFailure  = ${bad.isFailure}")
}

Hämta värdet

getOrNull returnerar värdet eller null. getOrThrow kastar undantaget igen vid fel. getOrDefault returnerar ett reservvärde.

fun main() {
    val r = runCatching { "42".toInt() }
    println(r.getOrNull())          // 42
    println(r.getOrDefault(-1))    // 42
    val bad = runCatching { "x".toInt() }
    println(bad.getOrNull())       // null
    println(bad.getOrDefault(0))   // 0
}

Hämta undantaget

exceptionOrNull() returnerar undantaget vid fel, eller null vid ett lyckat resultat.

fun main() {
    val r = runCatching { error("boom") }
    println(r.exceptionOrNull()?.message) // boom
}

Transformera med map

map { value -> ... } transformerar värdet vid ett lyckat resultat. Fel passerar igenom oförändrade.

fun main() {
    val r = runCatching { "10" }.map { it.toInt() * 2 }
    println(r.getOrNull()) // 20
}

mapCatching

mapCatching omsluter transformeringen i en try/catch, så att undantag inuti lambdauttrycket också blir felresultat.

fun main() {
    val r = runCatching { "abc" }.mapCatching { it.toInt() }
    println(r.isFailure) // true
    println(r.exceptionOrNull()?.message) // For input string: "abc"
}

recover och recoverCatching

recover { e -> fallback } omvandlar fel till lyckade resultat genom att beräkna ett återställningsvärde.

fun main() {
    val r = runCatching { "abc".toInt() }
        .recover { -1 }
    println(r.getOrNull()) // -1
}

onSuccess / onFailure

Använd onSuccess och onFailure för sidoeffekter utan att ändra Result.

fun main() {
    runCatching { "42".toInt() }
        .onSuccess { println("parsed: $it") }
        .onFailure { println("failed: ${it.message}") }
}

fold för båda vägarna

fold(onSuccess, onFailure) returnerar en enhetlig typ från endera grenen – användbart för att omvandla till ett UI-färdigt värde.

fun main() {
    val r = runCatching { "10".toInt() }
    val msg: String = r.fold(
        onSuccess = { "OK: $it" },
        onFailure = { "ERR: ${it.message}" }
    )
    println(msg)
}

Använda Result som returtyp

Funktioner kan returnera Result<T> för att göra felhanteringen tydlig på anropsplatsen.

fun parseInt(s: String): Result<Int> = runCatching { s.toInt() }
fun main() {
    parseInt("42").onSuccess { println("got $it") }
    parseInt("xx").onFailure { println("oops: ${it.message}") }
}

Kedja operationer

Kombinera runCatching med map, mapCatching och recover för flytande felhanteringskedjor.

fun fetchUserId(): Result<Int> = runCatching { 42 }
fun loadName(id: Int): String = "User-$id"
fun main() {
    val name = fetchUserId()
        .map { loadName(it) }
        .recover { "Anonymous" }
        .getOrNull()
    println(name)
}

Snabb kontroll

Vilken byggfunktion kör ett block och omsluter resultatet (värde eller undantag) i ett Result?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Result<T> representerar ett lyckat eller misslyckat resultat. Skapa med runCatching, transformera med map/mapCatching, återställ med recover, observera med onSuccess/onFailure och sammanfoga med fold. Det passar utmärkt för explicita felhanteringskedjor.

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 ”runCatching och Result<T>” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Kotlin Academy, inklusive ”runCatching och Result<T>”, 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 ”runCatching och Result<T>”?

Använd runCatching för att kapsla in exception i Result och behandla dem funktionellt. 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 ”runCatching och Result<T>”?

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

← Tillbaka till Kotlin Academy