Ruby | Manejo de excepciones – Part 1

En Ruby, el manejo de excepciones es un proceso que describe una forma de manejar el error generado en un programa. Aquí, error significa un evento no deseado o inesperado, que ocurre durante la ejecución de un programa, es decir, en tiempo de ejecución, que interrumpe el flujo normal de las instrucciones del programa. Así que este tipo de errores fueron manejados por el bloque de rescate . Ruby también proporciona una clase separada para una excepción que se conoce como clase de excepción que contiene diferentes tipos de métodos.
El código en el que se genera una excepción está encerrado entre el bloque de inicio/fin, por lo que puede usar una cláusula de rescate para manejar este tipo de excepción.

Sintaxis:

begin
    raise
      # block where exception raise

    rescue
      # block where exception rescue
end

Ejemplo:

# Ruby program to create the user 
# defined exception and handling it
   
# defining a method
def raise_and_rescue     
  begin
         
    puts 'This is Before Exception Arise!'
         
    # using raise to create an exception  
    raise 'Exception Created!'
   
    puts 'After Exception' 
   
  # using Rescue method
  rescue    
    puts 'Finally Saved!'    
     
end    
   
puts 'Outside from Begin Block!'    
   
end    
   
# calling method
raise_and_rescue   

Producción:

This is Before Exception Arise!
Finally Saved!
Outside from Begin Block!

Explicación: En el programa anterior, se genera una excepción en el bloque de inicio (bloque de elevación) que interrumpe el flujo de ejecución del programa. Para superar esta situación, use el bloque de rescate para manejar la excepción generada. Cuando se usa el bloque de rescate, maneja la excepción y continúa la ejecución del programa.

Nota: Se pueden usar varias cláusulas de rescate en el mismo programa, lo que significa que si la primera cláusula de rescate no maneja una excepción, entonces otra cláusula de rescate definitivamente manejará la excepción. Si ninguna cláusula de rescate coincide, o si ocurre una excepción fuera del bloque de inicio/fin, entonces Ruby sube a la pila y busca un controlador de excepciones en la persona que llama.

Las sentencias utilizadas en Excepciones son:

1. Declaración de reintento: esta declaración se utiliza para ejecutar el bloque de rescate nuevamente desde el principio después de capturar la excepción.

   Sintaxis:

   begin
       # block where exception raise
   
   rescue
       # block where an exception is captured
   
   retry
   
       # this statement restarts the rescue
       # block from the beginning
   end
   

   Ejemplo:

   # Ruby program to illustrate  # use of retry statement        begin               # using raise to create an exception       raise 'Exception Created!'         puts 'After Exception'        # using Rescue method   rescue         puts 'Finally Saved!'      # using retry statement   retry end

   Producción:

   Finally Saved!
   Finally Saved!
   Finally Saved!
   Finally Saved!
   Finally Saved!
   Finally Saved!
   .
   .
   .
   .
   

   Nota: tenga cuidado al usar la declaración de reintento porque puede resultar en un bucle infinito.

2. declaración de aumento: esta declaración se utiliza para generar una excepción.

   Sintaxis:

   raise

   Esta sintaxis se utiliza para volver a generar la excepción actual. Por lo general, lo utiliza el controlador de excepciones cuando se interrumpe una excepción antes de transmitirla.

   raise "Error Message"

   Esta sintaxis se usa para crear una excepción RuntimeError y genera la pila de llamadas.

   raise ExceptionType, "Error Message"

   En esta sintaxis, el primer argumento se usa para crear una excepción y luego establecer el mensaje en el segundo argumento.

   raise ExceptionType, "Error Message" condition

   En esta sintaxis, el primer argumento se usa para crear una excepción y luego establecer el mensaje en el segundo argumento. También puede establecer una declaración de condición para generar una excepción.

   Ejemplo:

   # Ruby program to illustrate  # use of raise statement    begin               puts 'This is Before Exception Arise!'                  # using raise to create an exception          raise 'Exception Created!'         puts 'After Exception'  end

   Producción:

   This is Before Exception Arise!
   Exception Created!
   

3. Instrucción de aseguramiento: esta instrucción garantiza que las instrucciones requeridas se ejecutarán al final del código, ya sea que se recupere la excepción generada o generada, o que el programa finalice debido a una excepción no detectada. Este bloque siempre da salida. Este bloque se coloca sobre el bloque de rescate.

   Sintaxis:

   begin
        # exception raise
   
   rescue
       # exception rescue
   
   ensure
       # this block always executes
   end
   

   Ejemplo:

   # Ruby program to illustrate  # use of ensure statement      begin               # using raise to create an exception       raise 'Exception Created!'         puts 'After Exception'        # using Rescue statement   rescue         puts 'Finally Saved!'      # using ensure statement   ensure    puts 'ensure block execute' end

   Producción:

   Finally Saved!
   ensure block execute
   

4. Declaración else: esta declaración está presente entre el bloque de rescate y el bloque de garantía. Este bloque solo se ejecuta cuando no se genera ninguna excepción.

   Sintaxis:

   begin
     rescue
       # exception rescue
     
     else
       # this block executes when no exception raise
   
     ensure
       # this block always executes
   end
   

   Ejemplo:

   # Ruby program to illustrate  # use of else statement     begin               # using raise to create an exception       # raise 'Exception Created!'         puts 'no Exception raise'         # using Rescue method     rescue             puts 'Finally Saved!'       #  using else statement    else         puts 'Else block execute because of no exception raise'            # using ensure statement      ensure       puts 'ensure block execute' end

   Producción:

   no Exception raise
   Else block execute because of no exception raise
   ensure block execute
   

Atrapar y lanzar en el manejo de excepciones

En Ruby, los bloques de captura y lanzamiento son el mecanismo liviano para el manejo de errores y se usan para saltar de la excepción cuando no hay trabajo adicional disponible en el programa.
El bloque catch se usa para saltar del bloque anidado y el bloque se etiqueta con un nombre. Este bloque funciona normalmente hasta que se encuentra con el bloque de lanzamiento. El método de atrapar y lanzar funcionará más rápido que el método de levantar y rescatar. Cuando se encuentra la instrucción throw, Ruby comprobará la pila de llamadas en busca de la instrucción catch con el símbolo relacionado. La instrucción throw nunca se ejecuta y siempre devuelve nil.

Sintaxis:

throw :label_name
    # this block will not be executed

catch :label_name do
    # matching catch will be executed when the throw block encounter
end

También puede aplicar una condición en la declaración de captura y lanzamiento como se muestra a continuación:

throw :label_name condition
     # this block will not be executed

catch :label_name do
     # matching catch will be executed when the throw block encounter
end

Ejemplo:

# Ruby program to illustrate  # use of catch and throw statement    # defining a  method  def catch_and_throw(value)      puts value   a = readline.chomp      # using throw statement   throw :value_e if a == "!"   return a    end    # using catch statement catch :value_e do    # enter number   number = catch_and_throw("Enter Number: ") end

Aporte:

Enter Number: 1

Producción:

1

Aporte:

Enter Number: !

Producción:

nil

Explicación: En el ejemplo anterior, el método catch_and_throw se usa para imprimir el valor ingresado en la instrucción catch. Si el usuario ingresa un número, imprimirá el número, pero si el usuario ingresa !, le dará cero. Porque la instrucción throw nunca se ha ejecutado efectivamente.