0Pricing
Kotlin Academy · Lekcja

runCatching i Result<T>

Użyj runCatching, aby opakować wyjątki w Result i przetwarzać je funkcyjnie.

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

Result<T> w skrócie

Result<T> to Kotlinowe opakowanie wyniku operacji: albo sukces z wartością typu T, albo niepowodzenie z obiektem typu Throwable.

Podstawy runCatching

runCatching { ... } wykonuje blok i opakowuje wynik w obiekt typu Result.

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

Pobieranie wartości

getOrNull zwraca wartość albo null. getOrThrow ponownie zgłasza wyjątek w razie niepowodzenia. getOrDefault zwraca wartość zastępczą.

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
}

Pobieranie wyjątku

exceptionOrNull() zwraca wyjątek w przypadku niepowodzenia albo null w przypadku sukcesu.

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

Przekształcanie za pomocą map

map { value -> ... } przekształca wartość oznaczającą sukces. Niepowodzenie pozostaje niezmienione.

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

mapCatching

mapCatching opakowuje przekształcenie w try/catch, dzięki czemu wyjątki występujące wewnątrz lambdy również stają się niepowodzeniami.

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

recover i recoverCatching

recover { e -> fallback } zamienia niepowodzenia w sukcesy, obliczając wartość odzyskiwania.

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

onSuccess / onFailure

Używaj onSuccess i onFailure do wykonywania efektów ubocznych bez zmieniania obiektu Result.

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

fold dla obu ścieżek

fold(onSuccess, onFailure) zwraca ujednolicony typ z dowolnej gałęzi — jest przydatne przy przekształcaniu wyniku na wartość gotową do użycia w interfejsie użytkownika.

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

Używanie Result jako typu zwracanego

Funkcje mogą zwracać Result<T>, aby jawnie wskazywać sposób obsługi błędów w miejscu wywołania.

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

Łączenie operacji

Połącz runCatching z funkcjami map, mapCatching i recover, aby tworzyć płynne potoki obsługi błędów.

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

Szybkie sprawdzenie

Który konstruktor wykonuje blok i opakowuje wynik (wartość lub wyjątek) w obiekt typu Result?

Podsumowanie

Result<T> reprezentuje sukces albo niepowodzenie. Twórz go za pomocą runCatching; przekształcaj za pomocą map/mapCatching; odzyskuj wynik za pomocą recover; reaguj za pomocą onSuccess/onFailure; łącz obie ścieżki za pomocą fold. To świetne rozwiązanie do jawnych potoków obsługi błędów.

Często zadawane pytania

Czy lekcja „runCatching i Result<T>” jest bezpłatna?

Tak — pełny tekst „runCatching i Result<T>” 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 „runCatching i Result<T>”?

Użyj runCatching, aby opakować wyjątki w Result i przetwarzać je funkcyjnie. Ć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 „runCatching i Result<T>”?

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. try/catch/finally jako wyrażenie
  2. Tworzenie własnych klas wyjątków
  3. runCatching i Result
  4. Ponowne rzucanie wyjątków i ich łańcuchowanie
← Powrót do Kotlin Academy