Erros, avisos e mensagens em R
Entenda os três tipos de sinais e quando cada um é gerado.
Erros, avisos e mensagens em R é uma aula grátis de R Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de R Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de R Academy inclui 4 aulas no total.
O sistema de condições do R
O R tem um sistema formal de condições para comunicar problemas. Há três classes principais de condições: erros (fatais — interrompem a execução), avisos (não fatais — são exibidos depois que o código termina) e mensagens (informativas — vão para 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() — Gerando erros
stop(msg) sinaliza uma condição de erro. A execução é interrompida imediatamente e a mensagem de erro é exibida. Ele é usado dentro de funções para abortar quando as entradas são inválidas ou quando uma situação irrecuperável é detectada.
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() — Avisos não fatais
warning(msg) sinaliza uma condição de aviso. Diferentemente dos erros, os avisos não interrompem a execução — a função continua e o aviso é coletado. Por padrão, os avisos são exibidos depois que todo o código termina, ou imediatamente se options(warn=1) estiver definido.
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() — Condições informativas
message(msg) sinaliza uma condição de mensagem. Ela vai para stderr, inclui uma quebra de linha automática e pode ser suprimida com suppressMessages(). Use-a para atualizações de progresso em funções, não para erros ou avisos.
load_data <- function(n) {
message('Loading ', n, ' records...')
seq_len(n)
}
data <- suppressMessages(load_data(100))
cat('Got', length(data), 'records\n')Objetos simpleError e simpleWarning
Quando o R cria uma condição, ele envolve a mensagem em um objeto de condição. simpleError('msg') e simpleWarning('msg') criam objetos de condição manualmente. Você pode examiná-los com 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() e conditionCall()
conditionMessage(cond) extrai a mensagem de texto de qualquer objeto de condição. conditionCall(cond) extrai a chamada que acionou a condição. Ambos são úteis dentro de manipuladores de erro para registrar ou sinalizar novamente condições.
tryCatch(
log(-1),
warning = function(w) {
cat('Caught warning :', conditionMessage(w), '\n')
cat('From call :', deparse(conditionCall(w)), '\n')
}
)options(warn = 2) — Tratar avisos como erros
Definir options(warn = 2) converte todos os avisos em erros, causando interrupções imediatas. Isso é útil durante o desenvolvimento para detectar cedo o código que gera avisos. Restaure com 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))Avisos imediatos ou adiados
Com options(warn = 0) (padrão), os avisos são coletados e exibidos no final. Com options(warn = 1), cada aviso é exibido imediatamente quando ocorre. Com warn = 2, eles se tornam erros.
# 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)Erro ou aviso: fatal ou não fatal
A distinção crítica é a seguinte: um erro interrompe completamente a execução, a menos que seja capturado por um manipulador. Um aviso é registrado, mas a execução continua. Isso significa que entradas inválidas podem produzir silenciosamente resultados incorretos se você usar avisos onde deveria usar erros.
# 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'))Aninhamento de condições
Condições podem ser geradas dentro de outros manipuladores de condição. Um manipulador de avisos pode chamar stop() para transformar um aviso em erro. Esse é um padrão comum para tornar mais rigoroso o código de terceiros.
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() e suppressMessages()
suppressWarnings(expr) avalia a expressão enquanto captura e descarta silenciosamente todos os avisos. suppressMessages(expr) faz o mesmo com as condições de mensagem. Use essas funções com moderação — suprimir avisos pode ocultar problemas reais.
# 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')Verificação rápida
Qual das afirmações a seguir sobre warning() e stop() está correta?
Condições: principais conclusões
Principais conclusões sobre as condições do R:
stop()= erro = fatal, interrompe imediatamente;warning()= não fatal, a execução continua;message()= informativa, vai para stderr- As três criam objetos de condição com hierarquia de classes
conditionMessage(e)extrai o texto de qualquer condiçãooptions(warn=1)exibe os avisos imediatamente;warn=2trata-os como errossuppressWarnings()/suppressMessages()silenciam condições- Prefira
stop()para entradas inválidas quando continuar seria incorreto
# 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'))Perguntas Frequentes
A aula “Erros, avisos e mensagens em R” é grátis?
Sim — o texto completo de “Erros, avisos e mensagens em R” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de R Academy, atualize para CoddyKit PRO. O curso de R Academy inclui 4 aulas no total.
O que vou aprender em “Erros, avisos e mensagens em R”?
Entenda os três tipos de sinais e quando cada um é gerado. Você pratica R Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar R Academy?
Nenhuma experiência prévia é necessária. R Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.
Quanto tempo leva a aula “Erros, avisos e mensagens em R”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de R Academy?
Sim. Cada aula de R Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Erros, avisos e mensagens em R
- tryCatch() para recuperação de erros
- withCallingHandlers() e reinicializações
- Escrevendo funções robustas com stop() e warning()