Kotlin Academy · Lektion

Funktionale Fehlerbehandlung

Verwenden Sie map und recover

Funktionale Fehlerbehandlung ist eine kostenlose Kotlin Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Kotlin Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.

Fehler als Datenflüsse

Funktionale Fehlerbehandlung betrachtet Fehler als Werte, die Sie umformen, verketten und aus denen Sie sich erholen können – genauso wie erfolgreiche Werte. Das integrierte Result bietet genau dafür Operatoren.

map

map wandelt einen erfolgreichen Wert um und lässt einen Fehler unverändert, sodass er unverändert weitergegeben wird.

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

Wenn die Umwandlung selbst eine Exception auslösen kann, fängt mapCatching diese Exception im Ergebnis auf, anstatt sie entweichen zu lassen.

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 wandelt einen Fehler wieder in einen Erfolg um, indem es anhand der Exception einen Wert berechnet. Ein Erfolg wird unverändert weitergegeben.

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

Wenn auch die Wiederherstellungslogik fehlschlagen kann, wrappt recoverCatching diesen Versuch, sodass alles ein Ergebnis bleibt.

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

onSuccess und onFailure

Diese führen Seiteneffekte aus, ohne das Ergebnis zu ändern, und geben es für weitere Verkettungen zurück. Ideal für Protokollierung.

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

Eine Pipeline verketten

Operatoren lassen sich zu einer übersichtlichen Pipeline zusammensetzen: erfassen, transformieren und Fehler behandeln – ganz ohne verschachteltes try/catch.

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

Mit fold zu einem endgültigen Wert

Beenden Sie eine Pipeline mit fold, um beide Zweige zu einem konkreten Wert zusammenzuführen, beispielsweise zu einer Meldung für den Benutzer.

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

Über einen benutzerdefinierten Typ mappen

Sie können Ihrem eigenen versiegelten Ergebnistyp dieselbe komfortable Verwendung ermöglichen, indem Sie Erweiterungsfunktionen wie map schreiben.

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)
}

Warum ein funktionaler Stil

Funktionale Fehlerbehandlung hält den Erfolgsweg übersichtlich, während Fehler deklarativ weitergereicht werden. Es gibt kein verstreutes try/catch, und das Typsystem verfolgt Fehler vom Anfang bis zum Ende.

Alles zusammenführen

Sie verfügen nun über ein vollständiges Werkzeugset:

map / mapCatching zum Transformieren
recover / recoverCatching zum Beheben von Fehlern
onSuccess / onFailure für Seiteneffekte
fold zum Abschließen

Schnelltest

Testen Sie Ihr Verständnis der funktionalen Fehlerbehandlung.

Zusammenfassung

Sie haben die funktionale Fehlerbehandlung kennengelernt:

Transformieren mit map / mapCatching
Fehler beheben mit recover / recoverCatching
Beobachten mit onSuccess / onFailure
Abschließen mit fold

Damit ist der Kurs zu Result und zur Modellierung von Fehlern abgeschlossen.

Häufig gestellte Fragen

Ist die Lektion „Funktionale Fehlerbehandlung“ kostenlos?

Ja — der vollständige Text von „Funktionale Fehlerbehandlung“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Kotlin Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Funktionale Fehlerbehandlung“?

Verwenden Sie map und recover Du übst Kotlin Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Kotlin Academy zu starten?

Keine Vorkenntnisse erforderlich. Kotlin Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Funktionale Fehlerbehandlung“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Kotlin Academy-Lektion Code schreiben und ausführen?

Ja. Jede Kotlin Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Kotlin Academy