R Academy · Aula

tryCatch() para recuperação de erros

Capture e trate erros, avisos e mensagens com tryCatch().

Aula 2 de 413 etapas

tryCatch() para recuperação de erros é uma aula grátis de R Academy no CoddyKit. Esta é a aula 2 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 que é tryCatch()?

tryCatch() permite executar uma expressão e interceptar quaisquer condições (erros, avisos e mensagens) que ela sinalize. Se a expressão for bem-sucedida, seu valor será retornado. Se ela sinalizar uma condição, o manipulador correspondente será chamado.

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

Capturando um erro

Quando a expressão dentro de tryCatch() chama stop(), a execução salta para o manipulador de error. O manipulador recebe o objeto de condição e retorna seu valor como resultado da chamada completa de 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')

Capturando um aviso

O manipulador de warning funciona da mesma forma que o de error, mas intercepta condições de aviso. Observação: quando um manipulador de warning é definido em tryCatch(), os avisos causam uma saída não local, assim como os erros — a execução não continua depois do aviso.

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

Capturando uma mensagem

Também é possível capturar condições de message(). Isso permite interceptar e reformular a saída informativa de funções que não estão sob seu controle. O manipulador recebe o objeto de condição, e o texto da mensagem inclui uma quebra de linha final.

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

A cláusula finally

O bloco finally sempre é executado depois da expressão — independentemente de ela ter sido concluída com sucesso, gerado um erro ou emitido um aviso. Use-o para código de limpeza, como fechar conexões, redefinir opções ou registrar a conclusão.

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')

Vários manipuladores

Você pode fornecer manipuladores para vários tipos de condição em uma única chamada de tryCatch(). R usa o primeiro manipulador aplicável. Se os manipuladores de error e warning estiverem definidos, os avisos serão capturados antes que possam se transformar em erros.

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')

Recuperação de erros em um laço

Um padrão muito prático é envolver o corpo de um laço em tryCatch() para que uma iteração malsucedida não interrompa o laço inteiro. Isso é essencial ao processar arquivos, chamadas de API ou entradas de usuários que podem falhar de maneira imprevisível.

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')

Retornando valores padrão significativos em caso de erro

Um padrão organizado consiste em retornar um valor padrão sensato pelo manipulador de erros. O valor retornado pelo manipulador se torna o resultado de tryCatch(). Retornar NA, NULL, 0 ou uma lista padrão funciona bem.

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')

Extraindo a mensagem de erro

Dentro de um manipulador de erros, use conditionMessage(e) ou a forma abreviada e$message para obter o texto do erro. Use conditionCall(e) ou e$call para obter a chamada que o desencadeou.

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

tryCatch() versus try()

R também oferece a função mais simples try(expr). Em caso de erro, ela retorna um objeto da classe 'try-error' em vez de interromper a execução. Use try() para expressões curtas de uma linha; use tryCatch() quando precisar de controle completo dos manipuladores ou de um bloco 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')
}

Aninhando chamadas de tryCatch()

As chamadas de tryCatch() podem ser aninhadas. Um tryCatch() interno captura as condições primeiro; se ele as relança (usando stop(e)), o manipulador externo captura a condição relançada.

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')

Verificação rápida

Em tryCatch(), qual cláusula é executada sempre, independentemente de ter ocorrido um erro?

Responda na aula interativa

tryCatch(): principais conclusões

Principais conclusões sobre tryCatch():

Intercepte erros com error = function(e) {...} e avisos com warning = function(w) {...}
O valor retornado pelo manipulador se torna o resultado de tryCatch()
finally é sempre executado — ideal para limpeza
Envolva os corpos dos laços em tryCatch() para realizar iterações robustas sobre entradas não confiáveis
e$message ou conditionMessage(e) extrai o texto do erro
try(expr, silent=TRUE) é uma alternativa mais simples de uma linha

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')

Grátis para começar

Aprenda R com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 43
Aulas: 159

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “tryCatch() para recuperação de erros” é grátis?

Sim — o texto completo de “tryCatch() para recuperação de erros” é 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 “tryCatch() para recuperação de erros”?

Capture e trate erros, avisos e mensagens com tryCatch(). 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 2 de 4.

Quanto tempo leva a aula “tryCatch() para recuperação de erros”?

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()

← Voltar para R Academy