0Pricing
Kotlin Academy · Lección

runCatching y Result<T>

Use runCatching para envolver excepciones en Result y procesarlas de forma funcional.

runCatching y Result<T> es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Kotlin Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Kotlin Academy incluye 4 lecciones en total.

Result<T> en pocas palabras

Result<T> es el contenedor de Kotlin para el resultado de una operación: puede ser un éxito con un valor de tipo T o un fallo con un Throwable.

Conceptos básicos de runCatching

runCatching { ... } ejecuta el bloque y encapsula el resultado en un Result.

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

Extraer el valor

getOrNull devuelve el valor o null. getOrThrow vuelve a lanzar la excepción si se produce un fallo. getOrDefault devuelve un valor alternativo.

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
}

Extraer la excepción

exceptionOrNull() devuelve la excepción si se produce un fallo o null si la operación tiene éxito.

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

Transformar con map

map { value -> ... } transforma el valor del éxito. El fallo pasa sin cambios.

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

mapCatching

mapCatching encapsula la transformación en un try/catch, de modo que las excepciones producidas dentro de la lambda también se convierten en fallos.

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

recover y recoverCatching

recover { e -> fallback } convierte los fallos en éxitos calculando un valor de recuperación.

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

onSuccess / onFailure

Utilice onSuccess y onFailure para realizar efectos secundarios sin modificar el Result.

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

fold para ambas rutas

fold(onSuccess, onFailure) devuelve un tipo unificado desde cualquiera de las dos ramas; resulta útil para convertir el resultado en un valor listo para la interfaz de usuario.

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

Usar Result como tipo de retorno

Las funciones pueden devolver Result<T> para hacer explícita la gestión de errores en el punto de llamada.

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

Encadenar operaciones

Combine runCatching con map, mapCatching y recover para crear canalizaciones fluidas de gestión de errores.

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

Comprobación rápida

¿Qué constructor ejecuta un bloque y encapsula el resultado (valor o excepción) en un Result?

Resumen

Result<T> representa un éxito o un fallo. Créelo con runCatching, transfórmelo con map/mapCatching, recupérelo con recover, obsérvelo con onSuccess/onFailure y unifique las ramas con fold. Es ideal para canalizaciones de errores explícitas.

Preguntas frecuentes

¿La lección «runCatching y Result<T>» es gratis?

Sí — el texto completo de «runCatching y Result<T>» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Kotlin Academy, actualiza a CoddyKit PRO. El curso de Kotlin Academy incluye 4 lecciones en total.

¿Qué aprenderé en «runCatching y Result<T>»?

Use runCatching para envolver excepciones en Result y procesarlas de forma funcional. Practicas Kotlin Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Kotlin Academy?

No se requiere experiencia previa. Kotlin Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «runCatching y Result<T>»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Kotlin Academy?

Sí. Cada lección de Kotlin Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. try/catch/finally como expresión
  2. Crear clases de excepciones personalizadas
  3. runCatching y Result
  4. Volver a lanzar excepciones y encadenarlas
← Volver a Kotlin Academy