El manejo de errores es un proceso en el que nos ocupamos de los errores no deseados o anómalos que pueden causar la terminación anormal del programa durante su ejecución. En R Programming , hay básicamente dos formas en las que podemos implementar un mecanismo de manejo de errores. O podemos llamar directamente a las funciones como stop() o warning(), o podemos usar las opciones de error como «warn» o «warning.expression». Las funciones básicas que se pueden usar para el manejo de errores en el código:
- stop(…) : Detiene la evaluación de la declaración actual y genera un argumento de mensaje. El control vuelve al nivel superior.
- esperando(…) : Su evaluación depende del valor de la opción de error advertir. Si el valor de la advertencia es negativo, se ignora. En caso de que el valor sea 0 (cero), se almacenan e imprimen solo después de que la función de nivel superior complete su ejecución. Si el valor es 1 (uno), se imprime tan pronto como se encuentra, mientras que si el valor es 2 (dos), la advertencia generada se convierte inmediatamente en un error.
- tryCatch(…) : Ayuda a evaluar el código y asignar las excepciones.
Manejo de condiciones en R
Generalmente, si encontramos errores inesperados mientras ejecutamos un programa, necesitamos una forma eficiente e interactiva de depurar el error y saber qué salió mal. Sin embargo, se esperan algunos errores, pero a veces los modelos no se ajustan y arrojan un error. Básicamente, existen tres métodos para manejar tales condiciones y errores en R:
- try() : nos ayuda a continuar con la ejecución del programa incluso cuando se presenta un error.
- tryCatch() : ayuda a manejar las condiciones y controlar lo que sucede en función de las condiciones.
- withCallingHandlers() : es una alternativa a tryCatch() que se encarga de los controladores locales.
intentar-atrapar-finalmente en R
A diferencia de otros lenguajes de programación como Java, C++, etc., las sentencias try-catch-finally se usan como una función en R. Las dos condiciones principales que se manejan en tryCatch() son «errores» y «advertencias».
Sintaxis:
check = tryCatch({
expression
}, warning = function(w){
code that handles the warnings
}, error = function(e){
code that handles the errors
}, finally = function(f){
clean-up code
})
Ejemplo:
R
# R program illustrating error handling
# Applying tryCatch
tryCatch(
# Specifying expression
expr = {
1 + 1
print("Everything was fine.")
},
# Specifying error message
error = function(e){
print("There was an error message.")
},
warning = function(w){
print("There was a warning message.")
},
finally = {
print("finally Executed")
}
)
Producción:
[1] "Everything was fine." [1] "finally Executed"
con CallingHandlers() en R
En R, withCallingHandlers() es una variante de tryCatch() . La única diferencia es que tryCatch() se ocupa de los controladores existentes, mientras que withCallingHandlers() se ocupa de los controladores locales.
Ejemplo:
R
# R program illustrating error handling
# Evaluation of tryCatch
check <- function(expression){
withCallingHandlers(expression,
warning = function(w){
message("warning:\n", w)
},
error = function(e){
message("error:\n", e)
},
finally = {
message("Completed")
})
}
check({10/2})
check({10/0})
check({10/'noe'})
Producción:
