Volver a lanzar excepciones y encadenarlas
Vuelva a lanzar excepciones de forma selectiva y envuelva errores de bajo nivel encadenando la causa.
Volver a lanzar excepciones y encadenarlas es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 4 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.
Volver a lanzar y envolver
A veces se captura una excepción únicamente para registrarla, envolverla o convertirla antes de permitir que se propague una excepción más específica. Kotlin facilita este patrón idiomático.
Volver a lanzar directamente
Para volver a lanzar una excepción, simplemente utilice throw e; la propagación continuará hasta el siguiente gestor.
fun main() {
try {
try { "x".toInt() }
catch (e: NumberFormatException) {
println("logging: ${e.message}")
throw e // re-throw original
}
} catch (e: NumberFormatException) {
println("outer caught: ${e.message}")
}
}Envolver con una excepción personalizada
Pase la excepción original como cause al construir una nueva para conservar la cadena.
class ParseException(msg: String, cause: Throwable) : RuntimeException(msg, cause)
fun main() {
try {
try { "xyz".toInt() }
catch (e: NumberFormatException) {
throw ParseException("could not parse user input", e)
}
} catch (e: ParseException) {
println("got: ${e.message}")
println("cause: ${e.cause?.message}")
}
}Inspeccionar la cadena de causas
La propiedad cause enlaza con la excepción anterior. Recorra la cadena para mostrar la causa raíz completa.
fun main() {
val e = RuntimeException("top",
RuntimeException("middle",
RuntimeException("root")))
var current: Throwable? = e
while (current != null) {
println(current.message)
current = current.cause
}
}Volver a lanzar selectivamente
Capture un tipo general y vuelva a lanzar la excepción si NO coincide con el caso esperado.
fun parseRequired(s: String): Int {
try {
return s.toInt()
} catch (e: NumberFormatException) {
if (s.isBlank()) return 0
throw e // unexpected — let it propagate
}
}
fun main() {
println(parseRequired("42"))
println(parseRequired(""))
// parseRequired("abc") // throws
}Añadir contexto
Envuelva la excepción con una excepción del dominio para añadir el contexto que faltaba en la original (entrada, id de solicitud, etc.).
class UploadError(msg: String, cause: Throwable) : RuntimeException(msg, cause)
fun upload(file: String) {
try { throw RuntimeException("disk full") }
catch (e: Throwable) { throw UploadError("uploading $file failed", e) }
}
fun main() {
try { upload("photo.jpg") }
catch (e: UploadError) { println("${e.message} <- ${e.cause?.message}") }
}No pierda el seguimiento de la pila
Al envolver una excepción, pase siempre la original como cause; nunca cree simplemente una excepción nueva con el mismo mensaje pero sin causa. El seguimiento de la pila es su recurso fundamental para depurar.
class Wrapped(m: String, cause: Throwable) : RuntimeException(m, cause)
fun main() {
try {
try { error("inner") }
catch (e: Throwable) { throw Wrapped("outer", e) }
} catch (e: Wrapped) {
println("message: ${e.message}")
println("cause: ${e.cause?.message}")
}
}Volver a lanzar sin envolver
Si solo necesita registrar la excepción, utilice throw e después de la llamada de registro; no es necesario envolverla.
fun risky() {
try { throw IllegalStateException("oops") }
catch (e: IllegalStateException) {
println("Logging before rethrow: ${e.message}")
throw e
}
}
fun main() {
try { risky() }
catch (e: IllegalStateException) { println("outer: ${e.message}") }
}finally para limpiar durante un relanzamiento
Utilice finally para limpiar los recursos incluso al volver a lanzar una excepción.
fun process() {
try {
throw RuntimeException("failure")
} finally {
println("cleanup ran")
}
}
fun main() {
try { process() }
catch (e: RuntimeException) { println("caught: ${e.message}") }
}Excepciones suprimidas
Si finally también lanza una excepción, la excepción original se suprime de forma predeterminada. Utilice addSuppressed para conservar ambas.
fun main() {
val primary = RuntimeException("primary")
val secondary = RuntimeException("from cleanup")
primary.addSuppressed(secondary)
println(primary.suppressed.joinToString { it.message ?: "?" })
}Antipatrón: ocultar una excepción y lanzar otra
Capturar una excepción y lanzar otra nueva no relacionada (sin causa) destruye la información de depuración. Pase siempre cause.
// BAD
// catch (e: IOException) { throw RuntimeException("error") }
// GOOD
// catch (e: IOException) { throw RuntimeException("error reading config", e) }
fun main() { println("Pass cause when re-throwing!") }Comprobación rápida
Al envolver una excepción en otra nueva, ¿qué debe hacer para conservar el seguimiento de pila original?
Resumen
Para volver a lanzarla: throw e. Para envolverla: lance una excepción nueva con cause = e. Preserve siempre la cadena de causas; nunca cree un envoltorio sin causa. Utilice finally para la limpieza y addSuppressed cuando la propia limpieza falle.
Preguntas frecuentes
¿La lección «Volver a lanzar excepciones y encadenarlas» es gratis?
Sí — el texto completo de «Volver a lanzar excepciones y encadenarlas» 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 «Volver a lanzar excepciones y encadenarlas»?
Vuelva a lanzar excepciones de forma selectiva y envuelva errores de bajo nivel encadenando la causa. 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 4 de 4.
¿Cuánto tiempo toma la lección «Volver a lanzar excepciones y encadenarlas»?
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
- try/catch/finally como expresión
- Crear clases de excepciones personalizadas
- runCatching y Result
- Volver a lanzar excepciones y encadenarlas