Errores, advertencias y mensajes en R
Comprenda los tres tipos de señales y cuándo se produce cada uno.
Errores, advertencias y mensajes en R es una lección gratuita de R 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 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.
El sistema de condiciones de R
R cuenta con un sistema de condiciones formal para comunicar problemas. Hay tres clases principales de condiciones: errores (fatales: detienen la ejecución), advertencias (no fatales: se muestran cuando termina el código) y mensajes (informativos: se envían a stderr).
# Each condition type behaves differently
message('This is a message')
warning('This is a warning')
# stop() would halt here, so wrap it
tryCatch(stop('This is an error'), error = function(e) print(e))stop() — Generación de errores
stop(msg) señala una condición de error. La ejecución se detiene inmediatamente y se muestra el mensaje de error. Se utiliza dentro de las funciones para abortar cuando las entradas no son válidas o se detecta una situación irrecuperable.
divide <- function(x, y) {
if (y == 0) stop('Division by zero is not allowed')
x / y
}
tryCatch(divide(10, 0), error = function(e) cat('Error:', conditionMessage(e), '\n'))
divide(10, 2)warning() — Advertencias no fatales
warning(msg) señala una condición de advertencia. A diferencia de los errores, las advertencias no detienen la ejecución: la función continúa y la advertencia se recopila. De forma predeterminada, las advertencias se muestran cuando termina todo el código, o inmediatamente si se establece options(warn=1).
safe_sqrt <- function(x) {
if (x < 0) {
warning('Negative input; returning NaN')
return(NaN)
}
sqrt(x)
}
result <- safe_sqrt(-4)
cat('Result:', result, '\n')message() — Condiciones informativas
message(msg) señala una condición de mensaje. Se envía a stderr, incluye un salto de línea automático y se puede suprimir con suppressMessages(). Utilícelo para actualizaciones de progreso en las funciones, no para errores ni advertencias.
load_data <- function(n) {
message('Loading ', n, ' records...')
seq_len(n)
}
data <- suppressMessages(load_data(100))
cat('Got', length(data), 'records\n')Objetos simpleError y simpleWarning
Cuando R crea una condición, incluye el mensaje en un objeto de condición. simpleError('msg') y simpleWarning('msg') crean objetos de condición manualmente. Puede inspeccionarlos con conditionMessage().
e <- simpleError('something went wrong')
w <- simpleWarning('this looks suspicious')
cat('Error class :', class(e), '\n')
cat('Warning class :', class(w), '\n')
cat('Error message :', conditionMessage(e), '\n')
cat('Warning msg :', conditionMessage(w), '\n')conditionMessage() y conditionCall()
conditionMessage(cond) extrae el mensaje de texto de cualquier objeto de condición. conditionCall(cond) extrae la llamada que desencadenó la condición. Ambas funciones son útiles dentro de los gestores de errores para registrar o volver a señalar condiciones.
tryCatch(
log(-1),
warning = function(w) {
cat('Caught warning :', conditionMessage(w), '\n')
cat('From call :', deparse(conditionCall(w)), '\n')
}
)options(warn = 2) — Tratar las advertencias como errores
Establecer options(warn = 2) convierte todas las advertencias en errores y provoca una detención inmediata. Resulta útil durante el desarrollo para detectar pronto el código que genera advertencias. Restablezca el comportamiento con options(warn = 0).
old_warn <- options(warn = 0) # default: collect warnings
log(-1) # just a warning
options(warn = 0)
tryCatch({
options(warn = 2)
log(-1) # now fatal
}, error = function(e) cat('Caught as error:', conditionMessage(e), '\n'),
finally = options(old_warn))Advertencias inmediatas frente a diferidas
Con options(warn = 0) (el valor predeterminado), las advertencias se recopilan y se muestran al final. Con options(warn = 1), cada advertencia se muestra inmediatamente cuando se produce. Con warn = 2, se convierten en errores.
# warn=1: print warnings immediately as they happen
old <- options(warn = 1)
result1 <- log(-1)
result2 <- sqrt(-4)
cat('Results:', result1, result2, '\n')
options(old)Error frente a advertencia: fatal frente a no fatal
La diferencia fundamental es la siguiente: un error detiene por completo la ejecución, a menos que un gestor lo capture. Una advertencia se registra, pero la ejecución continúa. Esto significa que las entradas incorrectas pueden producir resultados erróneos silenciosamente si utiliza advertencias donde debería utilizar errores.
# With warning: execution continues
f_warn <- function(x) { if (x < 0) warning('negative'); x^2 }
cat('warn result:', f_warn(-3), '\n') # still computes 9
# With error: execution stops
f_stop <- function(x) { if (x < 0) stop('negative'); x^2 }
tryCatch(f_stop(-3), error = function(e) cat('stopped:', e$message, '\n'))Anidación de condiciones
Las condiciones pueden producirse dentro de otros gestores de condiciones. Un gestor de advertencias puede llamar a stop() para convertir una advertencia en un error. Este es un patrón habitual para hacer más estricto el código de terceros.
strict_log <- function(x) {
withCallingHandlers(
log(x),
warning = function(w) {
stop(paste('Strict mode: warning treated as error:', conditionMessage(w)))
}
)
}
tryCatch(strict_log(-1), error = function(e) cat('Error:', e$message, '\n'))
cat('log(4) =', strict_log(4), '\n')suppressWarnings() y suppressMessages()
suppressWarnings(expr) evalúa la expresión mientras captura y descarta silenciosamente todas las advertencias. suppressMessages(expr) hace lo mismo con las condiciones de mensaje. Utilícelas con moderación: suprimir advertencias puede ocultar problemas reales.
# Without suppression: warning shown
result1 <- log(-1)
# With suppression: warning hidden
result2 <- suppressWarnings(log(-1))
cat('Both are NaN:', is.nan(result1), is.nan(result2), '\n')Comprobación rápida
¿Cuál de las siguientes afirmaciones sobre warning() frente a stop() es correcta?
Condiciones: conclusiones clave
Conclusiones clave sobre las condiciones de R:
stop()= error = fatal, detiene inmediatamente;warning()= no fatal, la ejecución continúa;message()= informativo, se envía a stderr- Las tres funciones crean objetos de condición con una jerarquía de clases
conditionMessage(e)extrae el texto de cualquier condiciónoptions(warn=1)muestra las advertencias inmediatamente;warn=2las trata como erroressuppressWarnings()/suppressMessages()silencian las condiciones- Prefiera
stop()para entradas no válidas cuando continuar produciría un resultado incorrecto
# Summary of the three condition functions
tryCatch({
message('Step 1 starting')
warning('something looks odd')
stop('cannot continue')
}, message = function(m) cat('MSG:', conditionMessage(m)),
warning = function(w) cat('WARN:', conditionMessage(w), '\n'),
error = function(e) cat('ERR:', conditionMessage(e), '\n'))Preguntas frecuentes
¿La lección «Errores, advertencias y mensajes en R» es gratis?
Sí — el texto completo de «Errores, advertencias y mensajes en R» 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 «Errores, advertencias y mensajes en R»?
Comprenda los tres tipos de señales y cuándo se produce cada uno. 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 1 de 4.
¿Cuánto tiempo toma la lección «Errores, advertencias y mensajes en R»?
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
- Errores, advertencias y mensajes en R
- tryCatch() para recuperar errores
- withCallingHandlers() y reinicios
- Escritura de funciones robustas con stop() y warning()