0Pricing
R Academy · Lección

tryCatch() para recuperar errores

Capture y gestione errores, advertencias y mensajes con tryCatch().

tryCatch() para recuperar errores es una lección gratuita de R Academy en CoddyKit. Esta es la lección 2 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 R Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de R Academy incluye 4 lecciones en total.

¿Qué es tryCatch()?

tryCatch() permite ejecutar una expresión e interceptar cualquier condición (errores, advertencias o mensajes) que esta señale. Si la expresión se ejecuta correctamente, se devuelve su valor. Si señala una condición, se llama al gestor correspondiente.

result <- tryCatch({
  sqrt(16)
}, error = function(e) {
  NA
})
cat('Result:', result, '\n')

Captura de un error

Cuando la expresión dentro de tryCatch() llama a stop(), la ejecución salta al gestor de error. El gestor recibe el objeto de condición y devuelve su valor como resultado de toda la llamada a tryCatch().

safe_divide <- function(x, y) {
  tryCatch({
    if (y == 0) stop('division by zero')
    x / y
  }, error = function(e) {
    cat('Caught error:', conditionMessage(e), '\n')
    NA
  })
}
cat(safe_divide(10, 2), '\n')
cat(safe_divide(10, 0), '\n')

Captura de una advertencia

El gestor de warning funciona igual que el de error, pero intercepta las condiciones de advertencia. Nota: una vez definido un gestor de warning en tryCatch(), las advertencias provocan una salida no local, igual que los errores; la ejecución no continúa después de la advertencia.

result <- tryCatch({
  log(-1)
}, warning = function(w) {
  cat('Warning caught:', conditionMessage(w), '\n')
  -999
})
cat('Result:', result, '\n')

Capturar un mensaje

También puede capturar condiciones de message(). Esto le permite interceptar y reformatear la salida informativa de funciones que no controla. El controlador recibe el objeto de condición y el texto del mensaje incluye un salto de línea final.

result <- tryCatch({
  message('Loading data...')
  42
}, message = function(m) {
  cat('Intercepted message:', trimws(conditionMessage(m)), '\n')
  -1
})
cat('Result:', result, '\n')

La cláusula finally

El bloque finally siempre se ejecuta después de la expresión, tanto si se completó correctamente como si produjo un error o una advertencia. Úselo para tareas de limpieza, como cerrar conexiones, restablecer opciones o registrar la finalización.

result <- tryCatch({
  cat('Trying...\n')
  stop('oops')
}, error = function(e) {
  cat('Handled:', e$message, '\n')
  -1
}, finally = {
  cat('Finally block always runs\n')
})
cat('Result:', result, '\n')

Varios controladores

Puede proporcionar controladores para varios tipos de condiciones en una sola llamada a tryCatch(). R utiliza el primer controlador aplicable. Si se definen controladores para error y warning, las advertencias se capturan antes de que puedan convertirse en errores.

handle_it <- function(expr_result) {
  tryCatch(expr_result,
    error   = function(e) paste('ERROR:', e$message),
    warning = function(w) paste('WARN:', w$message),
    message = function(m) paste('MSG:', trimws(m$message))
  )
}
cat(handle_it(stop('bad input')), '\n')
cat(handle_it(log(-1)), '\n')

Recuperación de errores en un bucle

Un patrón muy práctico consiste en envolver el cuerpo de un bucle en tryCatch() para que una iteración fallida no detenga todo el bucle. Esto es esencial al procesar archivos, llamadas a API o entradas del usuario que pueden fallar de forma impredecible.

inputs <- list(4, -1, 0, 16, 'x')
results <- vector('list', length(inputs))
for (i in seq_along(inputs)) {
  results[[i]] <- tryCatch(
    sqrt(as.numeric(inputs[[i]])),
    warning = function(w) NA,
    error   = function(e) NA
  )
}
cat('Results:', unlist(results), '\n')

Devolver valores predeterminados útiles en caso de error

Un patrón claro consiste en devolver un valor predeterminado razonable desde el controlador de errores. El valor devuelto por el controlador se convierte en el resultado de tryCatch(). Devolver NA, NULL, 0 o una lista predeterminada funciona bien.

safe_parse <- function(x) {
  tryCatch(
    as.numeric(x),
    warning = function(w) {
      cat('Cannot parse:', x, '-> using 0\n')
      0
    }
  )
}
cat(safe_parse('3.14'), '\n')
cat(safe_parse('abc'), '\n')
cat(safe_parse('99'), '\n')

Extraer el mensaje de error

Dentro de un controlador de errores, use conditionMessage(e) o la abreviatura e$message para obtener el texto del error. Use conditionCall(e) o e$call para obtener la llamada que lo desencadenó.

tryCatch(
  stop('file not found: data.csv'),
  error = function(e) {
    cat('Message:', conditionMessage(e), '\n')
    cat('Class  :', paste(class(e), collapse=', '), '\n')
  }
)

tryCatch() frente a try()

R también tiene la función más sencilla try(expr). En caso de error, devuelve un objeto de clase 'try-error' en lugar de detenerse. Use try() para expresiones breves de una sola línea; use tryCatch() cuando necesite controlar completamente los controladores o utilizar un bloque finally.

# try() returns try-error object on failure
result <- try(log('x'), silent = TRUE)
if (inherits(result, 'try-error')) {
  cat('try() caught error\n')
} else {
  cat('Result:', result, '\n')
}

Anidar llamadas a tryCatch()

Las llamadas a tryCatch() se pueden anidar. El tryCatch() interno captura primero las condiciones; si vuelve a lanzarlas mediante stop(e), el controlador externo captura la condición relanzada.

outer_result <- tryCatch({
  tryCatch({
    stop('inner error')
  }, error = function(e) {
    cat('Inner handler, re-throwing\n')
    stop(paste('Wrapped:', e$message))
  })
}, error = function(e) {
  cat('Outer handler:', e$message, '\n')
  'recovered'
})
cat('Final:', outer_result, '\n')

Comprobación rápida

En tryCatch(), ¿qué cláusula se ejecuta siempre, independientemente de si se produjo un error?

tryCatch(): conclusiones clave

Conclusiones clave sobre tryCatch():

  • Intercepte errores con error = function(e) {...} y advertencias con warning = function(w) {...}
  • El valor devuelto por el controlador se convierte en el resultado de tryCatch()
  • finally siempre se ejecuta, por lo que es ideal para tareas de limpieza
  • Envuelva los cuerpos de los bucles en tryCatch() para realizar iteraciones resistentes sobre entradas poco fiables
  • e$message o conditionMessage(e) extrae el texto del error
  • try(expr, silent=TRUE) es una alternativa más sencilla de una sola línea
safe_op <- function(x) {
  tryCatch({
    if (!is.numeric(x)) stop('not numeric')
    sqrt(x)
  }, error = function(e) {
    cat('Error:', e$message, '\n')
    NA
  }, finally = {
    cat('Done processing', x, '\n')
  })
}
cat(safe_op(9), '\n')
cat(safe_op('a'), '\n')

Preguntas frecuentes

¿La lección «tryCatch() para recuperar errores» es gratis?

Sí — el texto completo de «tryCatch() para recuperar errores» 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 R Academy, actualiza a CoddyKit PRO. El curso de R Academy incluye 4 lecciones en total.

¿Qué aprenderé en «tryCatch() para recuperar errores»?

Capture y gestione errores, advertencias y mensajes con tryCatch(). Practicas R 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 R Academy?

No se requiere experiencia previa. R 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 2 de 4.

¿Cuánto tiempo toma la lección «tryCatch() para recuperar errores»?

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 R Academy?

Sí. Cada lección de R 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. Errores, advertencias y mensajes en R
  2. tryCatch() para recuperar errores
  3. withCallingHandlers() y reinicios
  4. Escritura de funciones robustas con stop() y warning()
← Volver a R Academy