Kotlin Academy · Lekcja

Funkcjonalna obsługa błędów

Mapuj i odzyskuj

Lekcja 4 z 413 kroki

Funkcjonalna obsługa błędów to bezpłatna lekcja Kotlin Academy na CoddyKit. To lekcja 4 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.

Błędy jako przepływ danych

Funkcyjna obsługa błędów traktuje niepowodzenia jako wartości, które można przekształcać, łączyć i z których można odzyskiwać — tak samo jak przekształca się pomyślne wartości. Wbudowany Result udostępnia operatory dokładnie do tego celu.

map

map przekształca pomyślną wartość, a niepowodzenie pozostawia bez zmian, przekazując je dalej w niezmienionej postaci.

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

Jeśli samo przekształcenie może rzucać wyjątek, mapCatching przechwytuje go do wyniku zamiast pozwolić mu się wydostać.

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 przekształca niepowodzenie z powrotem w sukces, obliczając wartość na podstawie wyjątku. Sukces jest przekazywany dalej bez zmian.

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

Gdy logika odzyskiwania również może zakończyć się niepowodzeniem, recoverCatching opakowuje tę próbę, zachowując wszystko jako wynik.

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

onSuccess i onFailure

Wykonują efekty uboczne bez zmieniania wyniku, zwracając go do dalszego łańcuchowania. Świetnie nadają się do logowania.

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

Łączenie potoku

Operatory łączą się w przejrzysty potok: przechwytywanie, przekształcanie i odzyskiwanie — wszystko bez zagnieżdżonych bloków try/catch.

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

fold do wartości końcowej

Potok można zakończyć za pomocą fold, aby zredukować obie gałęzie do jednej konkretnej wartości, na przykład komunikatu wyświetlanego użytkownikowi.

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

Mapowanie własnego typu

Własnemu zapieczętowanemu typowi wyniku można zapewnić taką samą wygodę użycia, definiując funkcje rozszerzające, takie jak 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)
}

Dlaczego styl funkcyjny

Funkcyjna obsługa błędów sprawia, że główna ścieżka pozostaje czytelna, a błędy są przepuszczane przez kod w sposób deklaratywny. Nie ma rozproszonych bloków try/catch, a system typów śledzi błędy od początku do końca.

Połączenie wszystkiego

Mają Państwo teraz pełny zestaw narzędzi:

map / mapCatching do przekształcania
recover / recoverCatching do odzyskiwania
onSuccess / onFailure do obsługi efektów
fold do finalizacji

Szybkie sprawdzenie

Proszę sprawdzić zrozumienie funkcyjnej obsługi błędów.

Odpowiedz w interaktywnej lekcji

Podsumowanie

Poznali Państwo funkcyjną obsługę błędów:

Przekształcanie za pomocą map / mapCatching
Odzyskiwanie za pomocą recover / recoverCatching
Obserwowanie za pomocą onSuccess / onFailure
Finalizowanie za pomocą fold

To kończy kurs dotyczący Result i modelowania błędów.

Bezpłatny start

Ucz się Kotlin dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 51
Lekcje: 203

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Funkcjonalna obsługa błędów” jest bezpłatna?

Tak — pełny tekst „Funkcjonalna obsługa błędów” 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 „Funkcjonalna obsługa błędów”?

Mapuj i odzyskuj Ć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 4 z 4.

Ile czasu zajmuje lekcja „Funkcjonalna obsługa błędów”?

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

← Powrót do Kotlin Academy