Manejo de excepciones en Ruby
Este tutorial le mostrará cómo implementar el manejo de excepciones en Ruby usando los bloques de Raise and Rescue.
Uso básico
La mayoría de los lenguajes de programación implementan el manejo de excepciones utilizando el bloque de intentos y. Sin embargo, como todo lo demás en Ruby, las palabras clave son más descriptivas.
Podemos expresar la sintaxis general como se muestra a continuación:
comenzarRaiseException
# criar ecxeption
excepción de rescate
# bloque de rescate
fin
Adjuntamos el bloque de manejo de excepciones en una declaración de inicio y finalización. Dentro de estas declaraciones, definimos los bloques de aumento y rescate.
En el aumento, definimos la excepción, que podemos plantear manualmente o hacer que el intérprete Ruby lo genere. De forma predeterminada, el parámetro para el bloque de RAY es RuntimeError
El siguiente es el bloque de rescate. Como su nombre indica, este bloque viene al rescate cuando ocurre una excepción. Se necesita control de la ejecución del programa.
Ruby comparará la excepción elevada desde el bloque de subida contra los parámetros pasados al bloque de rescate. Si la excepción es del mismo tipo o una superclase, desencadena el bloque de rescate.
Ejemplo de manejo de excepciones en Ruby
Podemos implementar un ejemplo simple para ilustrar cómo funciona el manejo de excepciones en Ruby:
def err_mecomenzar
pone "Hola!"
elevar "tipo de cadena"
rescate
Ponga "No importa, estoy arreglado!"
fin
fin
err_me
En el ejemplo anterior, definimos una función con un bloque de excepción.
Levantamos manualmente una excepción, que interrumpe el flujo de ejecución del programa y ingresa al bloque de rescate. Esto realiza las acciones en el bloque en este caso, una declaración de put y sale.
Si agrega algún bloque de código inmediatamente después del aumento y antes del bloque de rescate, no se ejecutan porque el bloque de rescate maneja inmediatamente el flujo del programa.
Por defecto, el bloque de rescate utiliza el parámetro StandardError. Sin embargo, hay otros tipos de errores en Ruby, incluido.
- Error de sintaxis
- Ioerror
- Regexperror
- Treaterror
- ZeroDivisionError
- NometodeRor
- Índice
- Nombre de nombre
- Error de tecleado
Y más.
Para elevar y manejar un tipo de error específico, podemos pasarlo al bloque de elevación como parámetro. Aquí hay un ejemplo:
comenzarRaiserodivisionError
rescate => Excepción
Ponga excepción.mensaje
Ponga excepción.retroceso.inspeccionar
fin
En el ejemplo anterior, planteamos un ZeroDivisionError. Luego saltamos al bloque de rescate, que imprime el tipo de excepción específico y rastrea la fuente.
La salida resultante es:
$ ruby err-man-manejo.RBZeroDivisionError
["Err-man-manejo.RB: 2: en '' "]
Otros bloques de excepción
Además del bloque principal de elevación y rescate, Ruby también nos proporciona otros bloques que podemos implementar para manejar errores.
Incluyen:
Reintento
El bloque de reintento se usa para volver a ejecutar el bloque de rescate después de aumentar la excepción. Aquí hay un ejemplo:
comenzarelevar ZeroDivisionError
Ponga "No corro 😢"
rescate => Excepción
pone "#excepción.el mensaje me hizo morir ⚰️ "
rever
fin
Si ejecutamos el código anterior, imprimirá el mensaje dentro del bloque de rescate. Encontrará el bloque de reintento, que salta al bloque de rescate.
Un caso de uso común de los bloques de reintento es la prueba de errores utilizando la fuerza bruta. Un ejemplo sería seguir recargando una página cuando la conexión esté inactiva hasta que el error se resuelva.
PRECAUCIÓN: Tenga cuidado al usar el bloque de reintento porque es una fuente común de bucles infinitos.
Asegurar el bloque
Si ha programado en otro idioma como Python, probablemente esté familiarizado con el bloque Finalmente. El bloque de garantía en Ruby se desempeña de manera similar al bloque Finalmente en otros lenguajes de programación.
El bloque de asegurar siempre se ejecuta al final del código. Independientemente de si la excepción elevada se manejó correctamente o la ejecución del programa termina, siempre se ejecuta o ejecuta.
Aquí hay un ejemplo:
comenzarelevar ZeroDivisionError
Ponga "No corro 😢"
rescate => Excepción
pone "#excepción.el mensaje me hizo morir ⚰️ "
asegurar
Ponga "Siempre ejecutaré 🚀"
fin
En este caso, el código anterior imprimirá un mensaje de excepción y finalmente ejecutará el bloque de asegurar.
ZeroDivisionError me hizo morir ⚰️Siempre correré 🚀
Más bloque
Si no se plantea la excepción, podemos implementar un bloque para hacer una acción utilizando la instrucción delse.
Por ejemplo:
comenzarrescate => Excepción
pone "#excepción.el mensaje me hizo morir ⚰️ "
demás
pone "confía en mí, corrí con éxito" "
asegurar
pone "y siempre ejecutaré 🚀"
fin
El bloque de lo contrario se coloca entre el rescate y asegura el bloqueo. En el ejemplo anterior, notará que le falta un bloque de elevación, lo que hace que el bloque de lo contrario se ejecute.
Aquí hay una salida de ejemplo:
Confianza a mí, Corrí con éxito 😀
Y siempre ejecutaré 🚀Manejo de excepciones livianas
Los bloques de elevación y rescate son una forma útil de realizar una acción cuando ocurre un error. Sin embargo, debido a que el manejo de errores construye una rastro de pila para ayudar con la depuración, puede ser fácilmente problemático dentro de su programa. Aquí es donde entran los bloques de captura y lanzamiento.
Para implementar un bloque de tiros de captura, comienza definiendo la etiqueta usando la palabra clave de captura. Una vez que Ruby se encuentra con un bloque de lanzamiento que hace referencia al bloque de captura, detiene la ejecución y salta al bloque de captura.
Usemos un ejemplo para ilustrar este concepto. Considere la anidación desordenada que se muestra en el siguiente código:
Catch (: kill_me_now) dolangs = ["Python", "Ruby", "C ++", "C#"]
foriinlangsdo
para el índice en 1 ... 5
Si índice == 3
ifi == "C#"
Ponga "Después de lanzar, nada correrá!"
Throw (: kill_me_now)
pone "Soy C#"
fin
fin
fin
fin
fin
pone "Oh chico! Ese fue uno largo!"
Comenzamos usando la palabra clave de captura y pasamos la etiqueta dentro de un par de paréntesis. Una vez que ejecutemos el código, ejecutará todos los bucles anidados y si las declaraciones hasta que encuentre la declaración de lanzamiento que hace referencia a la captura.
Que finalizará inmediatamente la ejecución y la salida al nivel de la declaración de captura.
Aquí hay una salida de ejemplo:
Después de lanzar, nada correrá!'Oh chico! Ese fue uno largo!
Conclusión
Este tutorial le ha mostrado cómo implementar el manejo de errores en Ruby usando los bloques de Raise and Rescue.