Kotlin Academy · Les

runCatching

Vang uitzonderingen op als waarden

Les 2 van 413 stappen

runCatching is een gratis Kotlin Academy-les op CoddyKit. Dit is les 2 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Kotlin Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Kotlin Academy bevat in totaal 4 lessen.

Uitzonderingen vastleggen

runCatching voert een blok uit en verpakt de uitkomst ervan in een Result: de retourwaarde wordt een succes en elke gegooide uitzondering wordt een mislukking. Een try/catch is niet nodig.

Basisgebruik

Geef een lambda door; de laatste expressie is de succeswaarde.

fun main() {
    val r = runCatching { 10 / 2 }
    println(r.isSuccess)
    println(r.getOrNull())
}

Een gegooide fout opvangen

Wanneer het blok een uitzondering gooit, slaat runCatching de uitzondering op in plaats van deze door te geven.

fun main() {
    val r = runCatching { 10 / 0 }
    println(r.isFailure)
    println(r.exceptionOrNull()?.message)
}

Riskante parsering omwikkelen

Een veelvoorkomende toepassing is het omwikkelen van aanroepen die een uitzondering kunnen gooien, zoals parsering, zodat de mislukking een waarde wordt die je kunt afhandelen.

fun main() {
    val good = runCatching { "42".toInt() }
    val bad = runCatching { "abc".toInt() }
    println(good.getOrNull())
    println(bad.getOrNull())
}

runCatching als ontvanger

Je kunt runCatching aanroepen op een ontvangerobject; binnen het blok verwijst this daarnaar. Dat is handig om bewerkingen op een waarde aan elkaar te koppelen.

fun main() {
    val text = "  99 "
    val r = text.runCatching { trim().toInt() }
    println(r.getOrNull())
}

Inline herstellen

Combineer dit met getOrElse om direct op de plaats van de aanroep een terugvalwaarde te leveren.

fun main() {
    val n = runCatching { "oops".toInt() }.getOrElse { -1 }
    println(n)
}

fold voor beide takken

fold handelt succes en mislukking af in één aanroep en retourneert één waarde vanuit een van beide takken.

fun main() {
    val message = runCatching { "50".toInt() }.fold(
        onSuccess = { "got " + it },
        onFailure = { "error: " + it.message }
    )
    println(message)
}

try/catch herschrijven

Waar je misschien een try/catch zou schrijven die een waarde retourneert, is runCatching beknopter en blijft het resultaat gegevens.

fun safeDivide(a: Int, b: Int): Result<Int> =
    runCatching { a / b }

fun main() {
    println(safeDivide(8, 2).getOrNull())
    println(safeDivide(8, 0).exceptionOrNull()?.message)
}

Pas op met breed opvangen

runCatching vangt alle Throwables op, ook exemplaren die je misschien niet wilt inslikken. Wikkel geen enorme blokken in; houd het vastgelegde gebied klein en bewust gekozen.

Transformaties aan elkaar koppelen

Omdat runCatching een Result oplevert, kun je er direct map of recover aan koppelen. Die behandelen we in de volgende les.

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

Waarom dit helpt

runCatching vormt de brug tussen code die uitzonderingen gooit en de op waarden gebaseerde wereld van Result. Zo kun je foutafhandeling volgens een functionele stijl gebruiken, ook wanneer je API's aanroept die uitzonderingen gooien.

Korte test

Test je begrip van runCatching.

Samenvatting

Je hebt runCatching geleerd:

  • het verpakt de uitkomst van een blok in een Result
  • het zet gegooide uitzonderingen om in mislukkingen
  • combineer het met getOrElse en fold
  • houd vastgelegde gebieden klein

Hierna: verzegelde resultaat-hiërarchieën bouwen.

Gratis beginnen

Leer Kotlin met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen
51
Lessen
203

Veelgestelde vragen

Is de les “runCatching” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Kotlin Academy, waaronder “runCatching”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Kotlin Academy bevat in totaal 4 lessen.

Wat leer ik in “runCatching”?

Vang uitzonderingen op als waarden Je oefent met Kotlin Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Kotlin Academy te beginnen?

Ervaring vooraf is niet nodig. Kotlin Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “runCatching”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Kotlin Academy?

Ja. Elke les over Kotlin Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

  1. Het Result-type
  2. runCatching
  3. Sealed Result-hiërarchieën
  4. Functionele foutafhandeling
← Terug naar Kotlin Academy