Kotlin Academy · Lektion

Versiegelte Result-Hierarchien

Benutzerdefinierte Result-Typen

Versiegelte Result-Hierarchien ist eine kostenlose Kotlin Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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.

Über das integrierte Result hinaus

Kotlins Result enthält bei einem Fehler nur eine Exception. Oft benötigen Sie umfangreichere, typisierte Fehlerinformationen. Mit einer Hierarchie aus sealed classes können Sie genau die Ergebnisse modellieren, die in Ihrer Domäne vorkommen.

Ein versiegeltes Ergebnis

Definieren Sie einen versiegelten Typ mit Unterklassen für Erfolg und Fehler. Der Compiler kennt alle Fälle und ermöglicht eine vollständige Behandlung.

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

Vollständiges when

Da der Typ versiegelt ist, benötigt ein when darüber kein else, und der Compiler erzwingt die Behandlung jedes Falls.

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

Typisierte Fehlervarianten

Modellieren Sie verschiedene Fehlerarten als separate Unterklassen, die jeweils relevante Daten enthalten. Das ist besser als eine einzelne undurchsichtige Exception.

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

Jede Variante behandeln

Ein when kann gezielt auf jeden Fehlertyp reagieren, wobei für jeden Zweig alle Daten verfügbar sind.

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

Der Nothing-Trick

Fehlervarianten, die keinen Erfolgswert enthalten, verwenden Outcome<Nothing>. Da Nothing ein Untertyp jedes Typs ist und der generische Typ out verwendet, passt ein Fehler in jedes 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 zustandslose Fälle

Wenn eine Fehlervariante keine Daten enthält, deklarieren Sie sie als Singleton-object statt als Klasse.

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

Die Hierarchie zurückgeben

Funktionen geben den versiegelten Typ zurück; Aufrufer müssen jedes Ergebnis berücksichtigen, wodurch vergessene Fehlerpfade ausgeschlossen werden.

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

Versiegeltes Result im Vergleich zum integrierten Result

Verwenden Sie das integrierte Result für eine schnelle, auf Exceptions basierende Erfassung. Verwenden Sie eine benutzerdefinierte versiegelte Hierarchie, wenn Sie mehrere typisierte Fehlerfälle mit domänenspezifischen Daten und vollständiger Behandlung benötigen.

Die Hierarchie entwerfen

Ein gutes Design für ein versiegeltes Ergebnis:

Eine Erfolgsvariante, die die Nutzdaten enthält
Eine Unterklasse pro sinnvoller Fehlerart
Varianz mit out T und Nothing für Fälle, die nur einen Fehler enthalten

Der Compiler als Sicherheitsnetz

Der größte Vorteil: Wenn Sie später eine neue Variante hinzufügen, wird jedes nicht vollständige when zu einem Compilerfehler. Dieser zeigt Ihnen jede Stelle, an der die neue Variante behandelt werden muss. Fehler können nicht unbemerkt durchrutschen.

Kurzer Test

Testen Sie Ihr Verständnis versiegelter Result-Hierarchien.

Zusammenfassung

Sie haben versiegelte Result-Hierarchien erstellt:

Erfolgs- sowie typisierte Fehlervarianten
Vollständiges when ohne else
out T und Nothing für Fälle, die nur einen Fehler enthalten
Vom Compiler erzwungene Behandlung neuer Varianten

Als Nächstes: funktionale Fehlerbehandlung mit map und recover.

Häufig gestellte Fragen

Ist die Lektion „Versiegelte Result-Hierarchien“ kostenlos?

Ja — der vollständige Text von „Versiegelte Result-Hierarchien“ 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 „Versiegelte Result-Hierarchien“?

Benutzerdefinierte Result-Typen 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 3 von 4.

Wie lange dauert die Lektion „Versiegelte Result-Hierarchien“?

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