Manejo de condiciones en programación R

El manejo de decisiones o manejo de condiciones es un punto importante en cualquier lenguaje de programación. La mayoría de los casos de uso dan como resultado resultados positivos o negativos. A veces existe la posibilidad de verificación de condición de más de una posibilidad y se encuentra con n número de posibilidades. En este artículo, analicemos cómo funciona el manejo de condiciones en el lenguaje  R.

Comunicación de problemas potenciales 

Los desarrolladores siempre escriben buen código para lograr buenos resultados. No todos los problemas son inesperados. Pocos problemas potenciales esperados son,

• Dar el tipo incorrecto de entrada para una variable. En lugar de números, estamos dando valores alfanuméricos,
• Al cargar un archivo, la inexistencia de un archivo en la ubicación mencionada,
• La salida resultante después de calcular algún valor se espera como un valor numérico, pero la salida original está vacía, es nula o no es válida.

Durante estos escenarios, hay posibilidades de salir mal con R Code. Y a través de errores, advertencias y mensajes se pueden comunicar. Los errores fatales son generados por y obligan a terminar toda ejecución. Los errores se utilizan cuando no hay forma de que una función continúe. Las advertencias se generan y se utilizan para mostrar problemas potenciales, como cuando algunos elementos de una entrada vectorizada no son válidos, como log(-1:2). Los mensajes son generados por y se utilizan para dar salida informativa de una manera que el usuario puede suprimir fácilmente.

Manejo de condiciones programáticamente 

En el lenguaje R, existen tres herramientas diferentes para manejar condiciones, incluidos los errores mediante programación. Le brinda la capacidad de continuar la ejecución incluso cuando se produce un error. 
Ejemplo:

success <- try(100 + 200) 
failure <- try("100" + "200")

 
Producción:

Error in "100" + "200" : non-numeric argument to binary operator  

# Class of success
class(success) 

[1] "numeric"  

# Class of failure
class(failure) 

[1] "try-error" 

Cuando metemos el código dentro del bloque try, el código se ejecuta, incluso da error, y además para resultados correctos, será el último resultado evaluado, y si falla, dará con “try-error”. especifica funciones de controlador que controlan lo que sucede cuando se señala una condición. Uno puede tomar diferentes acciones para advertencias, mensajes e interrupciones. 
Ejemplo: 

# Using tryCatch()
display_condition <- function(inputcode)
{ 
  tryCatch(inputcode, 
           error = function(c) "Unexpected error occurred", 
           warning = function(c) "warning message, but
                                  still need to look into code", 
           message = function(c) "friendly message, but
                                   take precautions") 
}
 
# Calling the function
display_condition(stop("!")) 
display_condition(warning("?!")) 
display_condition(message("?")) 
display_condition(10000)

For Input: 
display_condition(stop("!")) 
Output: 
[1] "Unexpected error occurred" 
For Input: 
display_condition(warning("?!")) 
Output: 
[1] "warning message, but still need to look into code" 
For Input: 
display_condition(message("?")) 
Output: 
[1] "friendly message, but take precautions" 
For Input: 
display_condition(10000) 
Output: 
[1] 10000 

es una alternativa a. Establece controladores locales, mientras que registra controladores existentes. Esto será más útil para manejar un mensaje en lugar de, ya que este último detendrá el programa.
Ejemplo:

# Using tryCatch()
message_handler <- function(c) cat("Important message is caught!\n") 
    tryCatch(message = message_handler,
    { 
        message("1st value printed?") 
      message("Second value too printed!") 
    })

 Producción: 

Important message is caught! 

# Using withCallingHandlers()
message_handler <- function(c) cat("Important message is caught!\n") 
withCallingHandlers(message = message_handler,
    { 
      message("1st value printed?") 
      message("Second value too printed!") 
    })

 Producción: 

Important message is caught!
1st value printed?
Important message is caught!
Second value too printed!

Clases de señales personalizadas 

Uno de los desafíos del manejo de errores en R es que la mayoría de las funciones simplemente llaman con una string. Por ejemplo, los errores «esperados» (como un modelo que no logra converger para algunos conjuntos de datos de entrada) se pueden ignorar silenciosamente, mientras que los errores inesperados (como la falta de espacio en disco disponible) se pueden propagar al usuario. 
Ejemplo:

# R program to illustrate
# Custom signal classes
 
condition <- function(subclass, message,
                      call = sys.call(-1), ...) {
  structure(
    class = c(subclass, "condition"),
    list(message = message, call = call),
    ...
  )
}
 
is.condition <- function(x) inherits(x, "condition")
e <- condition(c("my_error", "error"),
               "Unexpected error occurred")
stop(e) # Output as Unexpected error occurred
 
# comment out stop(e)
w <- condition(c("my_warning", "warning"),
                  "Appropriate warning!!!!")
warning(w) # Output as Appropriate warning!!!!
           # as well as Important message to be noted!!
           # will be printed
 
m <- condition(c("my_message", "message"),
               "Important message to be noted!!!")
message(m) # Output as Important message to be noted!!!

 Producción: 

Error: Unexpected error occurred 
Execution halted

Pero al mismo tiempo, si la línea está comentada, se imprimen tanto la advertencia como el mensaje. 

Warning message: 
Appropriate warning!!!! 
Important message to be noted!! 

Y si se comenta la advertencia (w), entonces 

Important message to be noted!! 

Entonces, al usar clases de señales personalizadas, podemos diferenciar los errores. Podemos verlo en detalle a continuación 
. Ejemplo: 

# R program to illustrate
# Custom signal classes
 
condition <- function(subclass, message,
                      call = sys.call(-1), ...) {
  structure(
    class = c(subclass, "condition"),
    list(message = message, call = call),
    ...
  )
}
is.condition <- function(x) inherits(x, "condition")
custom_stop <- function(subclass, message,
                        call = sys.call(-1),
                        ...) {
c <- condition(c(subclass, "error"), message,
               call = call, ...)
  stop(c)
}
 
check_log <- function(x) {
  if (!is.numeric(x))
    custom_stop("invalid_class",
                "check_log() needs numeric input")
  if (any(x < 0))
    custom_stop("invalid_value",
                "check_log() needs positive inputs")
  log(x)
}
 
tryCatch(
  check_log("ant"),  # As we pass "ant", we will
                     # get Numeric inputs
                     # only are allowed as output
   
  # for input, if we give with negative value
  # let us check what happens,
  # for that uncomment below line and see,
  # obviously you get Positive
  # numeric value need to be provided
  #check_log("-100"),
  invalid_class = function(c) "Numeric inputs
                               only are allowed",
  invalid_value = function(c) "Positive numeric value
                               need to be provided"
)

 Producción: 

[1] "Numeric inputs only are allowed" 

Pero al mismo tiempo, cuando pasamos check_log(“100”), 

[1] "Only positive values are allowed"