0Pricing
Kotlin Academy · Lección

try/catch/finally como expresión

Use try-catch como expresión para devolver valores desde código propenso a errores.

try/catch/finally como expresión es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 1 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.

try es una expresión

En Kotlin, try/catch es una expresión: devuelve un valor. La última expresión del bloque try o catch es el resultado.

try/catch básico

Incluya en un bloque try el código que podría lanzar una excepción y gestione las excepciones en catch.

fun main() {
    try {
        val n = "abc".toInt()
        println(n)
    } catch (e: NumberFormatException) {
        println("Not a number: ${e.message}")
    }
}

try devuelve un valor

Asigne el resultado de un try/catch a una variable. El valor es el que produzca el bloque que coincida.

fun main() {
    val n: Int = try {
        "42".toInt()
    } catch (e: NumberFormatException) {
        -1
    }
    println(n) // 42
}

try en el cuerpo de una función

Puede utilizar try como cuerpo de una función cuyo cuerpo sea una expresión.

fun parseOrDefault(s: String, default: Int): Int = try {
    s.toInt()
} catch (e: NumberFormatException) {
    default
}
fun main() {
    println(parseOrDefault("42", 0))   // 42
    println(parseOrDefault("abc", 0))  // 0
}

Varias cláusulas catch

Enumere varias cláusulas catch para distintos tipos de excepciones. Se utiliza la primera coincidencia.

fun main() {
    val result: String = try {
        val list = listOf(1)
        list[5].toString()
    } catch (e: IndexOutOfBoundsException) {
        "index out of bounds"
    } catch (e: Exception) {
        "other error"
    }
    println(result)
}

Bloque finally

finally siempre se ejecuta y se utiliza para la limpieza. NO afecta al valor devuelto por la expresión try.

fun main() {
    val n: Int = try {
        "42".toInt()
    } catch (e: NumberFormatException) {
        -1
    } finally {
        println("cleanup runs")
    }
    println("value = $n")
}

try con varias instrucciones

Utilice un bloque con varias instrucciones; el valor será el de la última expresión.

fun main() {
    val result: String = try {
        val n = 10 / 2
        val s = "Result is $n"
        s.uppercase()
    } catch (e: Exception) {
        "ERROR"
    }
    println(result) // RESULT IS 5
}

Capturar varios tipos

Kotlin no admite la sintaxis multi-catch de Java (catch (A | B)). Utilice un supertipo común o cláusulas catch independientes.

fun parse(s: String): Int = try {
    s.toInt()
} catch (e: RuntimeException) { // covers NumberFormatException etc.
    -1
}
fun main() {
    println(parse("42"))
    println(parse("nope"))
}

El orden de catch es importante

Enumere las excepciones específicas antes que sus supertipos; de lo contrario, el supertipo capturará primero la excepción.

fun main() {
    try {
        throw NumberFormatException("oops")
    } catch (e: NumberFormatException) {
        println("specific: ${e.message}")
    } catch (e: Exception) {
        println("generic")
    }
}

Devolver desde try

Puede utilizar return para salir antes desde el interior de try; el bloque finally se seguirá ejecutando.

fun process(x: Int): String {
    return try {
        require(x > 0) { "must be positive" }
        "ok: $x"
    } catch (e: IllegalArgumentException) {
        "error: ${e.message}"
    } finally {
        println("processing done")
    }
}
fun main() {
    println(process(5))
    println(process(-1))
}

Antipatrón: catch vacío

Los bloques catch vacíos ocultan los errores. Como mínimo, registre la excepción o vuelva a lanzarla.

fun main() {
    try {
        "abc".toInt()
    } catch (e: NumberFormatException) {
        // BAD: silently swallow
    }
    println("continued")
}

Comprobación rápida

En Kotlin, ¿qué valor produce una expresión try/catch?

Resumen

try/catch es una expresión: devuelve un valor. Enumere las excepciones específicas antes que sus supertipos, utilice finally para la limpieza y evite los bloques catch vacíos. Puede utilizarla como cuerpo de una función o para asignar un valor predeterminado en caso de error.

Preguntas frecuentes

¿La lección «try/catch/finally como expresión» es gratis?

Sí — el texto completo de «try/catch/finally como expresión» 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 «try/catch/finally como expresión»?

Use try-catch como expresión para devolver valores desde código propenso a errores. 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 1 de 4.

¿Cuánto tiempo toma la lección «try/catch/finally como expresión»?

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