0Pricing
Kotlin Academy · Lekcja

Zapieczętowane hierarchie Result

Niestandardowe typy wyników

Zapieczętowane hierarchie Result to bezpłatna lekcja Kotlin Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Kotlin Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Kotlin Academy zawiera 4 lekcji w sumie.

Poza wbudowanym Result

Kotlinowy Result przechowuje podczas niepowodzenia tylko wyjątek. Często potrzebne są bogatsze, typowane informacje o błędach. Hierarchia klas sealed pozwala dokładnie modelować wyniki możliwe w danej domenie.

Wynik typu sealed

Zdefiniuj typ sealed z podklasami sukcesu i błędu. Kompilator zna wszystkie przypadki, co umożliwia kompletną obsługę.

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

Kompletna instrukcja when

Ponieważ typ jest sealed, instrukcja when dla tego typu nie wymaga else, a kompilator wymusza obsługę każdego przypadku.

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

Typowane warianty błędów

Modeluj różne rodzaje niepowodzeń jako osobne podklasy, z których każda przechowuje istotne dane. To lepsze rozwiązanie niż pojedynczy, nieprzejrzysty wyjątek.

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

Obsługa poszczególnych wariantów

Instrukcja when może reagować osobno na każdy typ błędu, zapewniając dostęp do wszystkich danych w danej gałęzi.

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

Sztuczka z Nothing

Warianty błędów, które nie zawierają wartości sukcesu, używają Outcome<Nothing>. Ponieważ Nothing jest podtypem każdego typu, a parametr generyczny jest oznaczony jako out, błąd pasuje do dowolnego 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 dla przypadków bez stanu

Jeśli wariant błędu nie przechowuje żadnych danych, należy zadeklarować go jako pojedynczy obiekt object zamiast klasy.

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

Zwracanie hierarchii

Funkcje zwracają typ sealed; wywołujący muszą uwzględnić każdy wynik, co eliminuje pominięte ścieżki błędów.

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 a wbudowany Result

Wbudowanego Result używaj do szybkiego przechwytywania opartego na wyjątkach. Własnej hierarchii sealed używaj, gdy potrzebujesz wielu typowanych przypadków błędów z danymi specyficznymi dla domeny oraz kompletnej obsługi.

Projektowanie hierarchii

Dobrze zaprojektowany wynik sealed:

  • Jeden wariant sukcesu przechowujący dane
  • Jedna podklasa dla każdego istotnego rodzaju niepowodzenia
  • Zmienność out T oraz Nothing dla przypadków zawierających wyłącznie błąd

Kompilator jako siatka bezpieczeństwa

Największą korzyścią jest to, że gdy później dodasz nowy wariant, każde niekompletne when stanie się błędem kompilacji wskazującym każde miejsce, które musi go obsłużyć. Błędy nie mogą przejść niezauważone.

Szybkie sprawdzenie

Sprawdź swoją wiedzę na temat hierarchii wyników sealed.

Podsumowanie

Zbudowano hierarchie wyników sealed:

  • Sukces oraz typowane warianty błędów
  • Kompletne when bez else
  • out T i Nothing dla przypadków zawierających wyłącznie błąd
  • Obsługa nowych wariantów wymuszana przez kompilator

Następnie: funkcyjna obsługa błędów za pomocą map i recover.

Często zadawane pytania

Czy lekcja „Zapieczętowane hierarchie Result” jest bezpłatna?

Tak — pełny tekst „Zapieczętowane hierarchie Result” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Kotlin Academy, przejdź na CoddyKit PRO. Kurs Kotlin Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Zapieczętowane hierarchie Result”?

Niestandardowe typy wyników Ćwiczysz Kotlin Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Kotlin Academy?

Nie wymagamy żadnego doświadczenia. Kotlin Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Zapieczętowane hierarchie Result”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Kotlin Academy?

Tak. Każda lekcja Kotlin Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Typ Result
  2. runCatching
  3. Zapieczętowane hierarchie Result
  4. Funkcjonalna obsługa błędów
← Powrót do Kotlin Academy