A função trycatch()é bastante simples e existem muitos bons tutoriais sobre isso. Uma excelente explicação do tratamento de erros em R pode ser encontrada no livro Advanced-R de Hadley Wickham , e o que se segue é uma introdução muito básica withCallingHandlers()e withRestarts()com o mínimo de palavras possível:
Digamos que um programador de baixo nível escreva uma função para calcular o valor absoluto. Ele não tem certeza de como calculá-lo, mas sabe como construir um erro e transmite diligentemente sua ingenuidade:
low_level_ABS <- function(x){
if(x<0){
#construct an error
negative_value_error <- structure(
# with class `negative_value`
class = c("negative_value","error", "condition"),
list(message = "Not Sure what to with a negative value",
call = sys.call(),
# and include the offending parameter in the error object
x=x))
# raise the error
stop(negative_value_error)
}
cat("Returning from low_level_ABS()\n")
return(x)
}
Um programador de nível médio também escreve uma função para calcular o valor absoluto, fazendo uso da low_level_ABSfunção lamentavelmente incompleta . Ele sabe que o código de baixo nível gera um negative_value
erro quando o valor de xé negativo e sugere uma solução para o problema, estabelecendo umrestart que permite aos usuários de mid_level_ABScontrolar a forma como se mid_level_ABSrecupera (ou não) de um negative_valueerro.
mid_level_ABS <- function(y){
abs_y <- withRestarts(low_level_ABS(y),
# establish a restart called 'negative_value'
# which returns the negative of it's argument
negative_value_restart=function(z){-z})
cat("Returning from mid_level_ABS()\n")
return(abs_y)
}
Finalmente, um programador de alto nível usa o mid_level_ABS função para calcular o valor absoluto e estabelece um manipulador de condição que diz ao
mid_level_ABSpara se recuperar de um negative_valueerro usando o manipulador de reinicialização.
high_level_ABS <- function(z){
abs_z <- withCallingHandlers(
# call this function
mid_level_ABS(z) ,
# and if an `error` occurres
error = function(err){
# and the `error` is a `negative_value` error
if(inherits(err,"negative_value")){
# invoke the restart called 'negative_value_restart'
invokeRestart('negative_value_restart',
# and invoke it with this parameter
err$x)
}else{
# otherwise re-raise the error
stop(err)
}
})
cat("Returning from high_level_ABS()\n")
return(abs_z)
}
O ponto de tudo isso é que usando withRestarts()e withCallingHandlers(), a função
high_level_ABSfoi capaz de dizer mid_level_ABScomo se recuperar de erros levantados porlow_level_ABS erro sem interromper a execução de
mid_level_ABS, que é algo que você não pode fazer com tryCatch():
> high_level_ABS(3)
Returning from low_level_ABS()
Returning from mid_level_ABS()
Returning from high_level_ABS()
[1] 3
> high_level_ABS(-3)
Returning from mid_level_ABS()
Returning from high_level_ABS()
[1] 3
Na prática, low_level_ABSrepresenta uma função que mid_level_ABSchama muito (talvez até milhões de vezes), para a qual o método correto de tratamento de erros pode variar de acordo com a situação, e a escolha de como tratar erros específicos é deixada para funções de nível superior ( high_level_ABS).