Gestion des exceptions dans Ruby

Le traitement des exceptions fait référence au processus de prédiction et de définition des moyens de gérer les erreurs soulevées dans un programme pendant l'exécution. Une erreur, dans la plupart des cas, fait référence à un événement ou à un événement inattendu lors de l'exécution du programme. Par exemple, une erreur peut se produire lors de la lecture d'un fichier en raison du fichier qui n'est pas existant ou de l'utilisateur n'ayant pas la bonne autorisation de lire ou d'écrire dans le fichier.

Ce tutoriel vous montrera comment implémenter la gestion des exceptions dans Ruby en utilisant les blocs Raisie et Rescue.

Utilisation de base

La plupart des langages de programmation implémentent la gestion des exceptions en utilisant le bloc d'essai et de capture. Cependant, comme tout le reste de Ruby, les mots clés sont plus descriptifs.

Nous pouvons exprimer la syntaxe générale comme indiqué ci-dessous:

commencer
Raisiexception
# Richer EcxEption
exception de sauvetage
# bloc de sauvetage
fin

Nous entourons le bloc de gestion des exceptions dans une déclaration de début et de fin. À l'intérieur de ces déclarations, nous définissons les blocs d'élévation et de sauvetage.

Dans l'augmentation, nous définissons l'exception, que nous pouvons soulever manuellement ou que l'interprète Ruby le généra. Par défaut, le paramètre du bloc d'élévation est RuntimeError

Vient ensuite le bloc de sauvetage. Comme son nom l'indique, ce bloc arrive à la rescousse lorsqu'une exception se produit. Il prend le contrôle de l'exécution du programme.

Ruby comparera l'exception soulevée du bloc d'élévation contre les paramètres transmis au bloc de sauvetage. Si l'exception est du même type ou d'une superclasse, elle déclenche le bloc de sauvetage.

Exemple de gestion des exceptions dans Ruby

Nous pouvons implémenter un exemple simple pour illustrer comment la gestion des exceptions fonctionne dans Ruby:

def err_me
commencer
met "salut là-bas!"
augmenter "Type de chaîne"
sauvetage
met "tant pis, je suis fixe!"
fin
fin
err_me

Dans l'exemple ci-dessus, nous définissons une fonction avec un bloc d'exception.

Nous soulevons manuellement une exception, qui interrompt le flux d'exécution du programme et entre dans le bloc de sauvetage. Cela effectue les actions dans le bloc dans cette affaire, une déclaration de put et sort.

Si vous ajoutez un bloc de code immédiatement après l'augmentation et avant le bloc de sauvetage, ils ne s'exécutent pas car le bloc de sauvetage gère immédiatement le flux du programme.

Par défaut, le bloc de sauvetage utilise le paramètre StandardError. Cependant, il existe d'autres types d'erreurs dans Ruby, notamment.

1. Erreur de syntaxe
2. Ioerror
3. Regexperror
4. Threaderror
5. Zérodivisionerror
6. Nomthoderner
7. Indexerror
8. Noméror
9. Erreur-type

Et plus.

Pour soulever et gérer un type d'erreur spécifique, nous pouvons le transmettre au bloc d'élévation en tant que paramètre. Voici un exemple:

commencer
roomzerodivisionerror
Rescue => Exception
met l'exception.message
met l'exception.retour.inspecter
fin

Dans l'exemple ci-dessus, nous élevons un zérodivisionError. Nous sautions ensuite dans le bloc de sauvetage, qui imprime le type d'exception spécifique et retrace la source.

La sortie résultante est:

$ Ruby Err-Handling.RB
Zérodivisionerror
["Err-Handling.RB: 2: dans '' "]

Autres blocs d'exception

Outre le bloc d'élévation et de sauvetage principal, Ruby nous fournit également d'autres blocs que nous pouvons implémenter pour gérer les erreurs.

Ils comprennent:

Bloc de réessayer

Le bloc de réessayer est utilisé pour réinstaller le bloc de sauvetage après avoir augmenté l'exception. Voici un exemple:

commencer
élever ZerodivisionError
met "je ne cours pas 😢"
Rescue => Exception
met "# exception.Message m'a fait mourir ⚰️ "
recommencez
fin

Si nous exécutons le code ci-dessus, il imprimera le message à l'intérieur du bloc de sauvetage. Il rencontrera le bloc de réessayer, qui saute dans le bloc de sauvetage.

Un cas d'utilisation courant de blocs de réessayer est de sonder les erreurs en utilisant la force brute. Un exemple serait de continuer à recharger une page lorsque la connexion est en panne jusqu'à ce que l'erreur se résout.

AVERTIR: Soyez prudent lorsque vous utilisez le bloc de réessayer car il s'agit d'une source commune de boucles infinies.

Assurer le blocage

Si vous avez programmé dans une autre langue comme Python, vous connaissez probablement le bloc final. Le bloc d'assurance dans Ruby fonctionne de la même manière que le bloc final dans d'autres langages de programmation.

Le bloc d'assurance s'exécute toujours à la fin du code. Indépendamment du fait que l'exception surélevée ait été gérée correctement ou que l'exécution du programme se termine, elle s'exécute toujours ou exécute.

Voici un exemple:

commencer
élever ZerodivisionError
met "je ne cours pas 😢"
Rescue => Exception
met "# exception.Message m'a fait mourir ⚰️ "
assurer
met "je vais toujours courir 🚀"
fin

Dans ce cas, le code ci-dessus imprimera un message d'exception et exécutera enfin le bloc Assurer.

ZerodivisionError m'a fait mourir ⚰️
Je vais toujours courir 🚀

Else Block

Si aucune exception n'est élevée, nous pouvons implémenter un bloc pour effectuer une action en utilisant l'instruction ELSE.

Par exemple:

commencer
Rescue => Exception
met "# exception.Message m'a fait mourir ⚰️ "
autre
Mette "Croyez-moi, j'ai couru avec succès 😀"
assurer
met "et je courirai toujours 🚀"
fin

Le bloc Else est placé entre le sauvetage et assurer le bloc. Dans l'exemple ci-dessus, vous remarquerez qu'il manque un bloc d'élévation, ce qui fait fonctionner le bloc Else.

Voici un exemple de sortie:

Confiance moi, J'ai couru avec succès 😀

Et je vais toujours courir 🚀

Gestion des exceptions légères

Les blocs d'augmentation et de sauvetage sont un moyen pratique d'effectuer une action lorsqu'une erreur se produit. Cependant, comme la gestion des erreurs construit une trace de pile pour aider à déboguer, il peut facilement devenir problématique dans votre programme. C'est là que les blocs de capture et de lancer entrent.

Pour implémenter un bloc de lancement à fourrure, vous commencez par définir l'étiquette à l'aide du mot clé Catch. Une fois que Ruby rencontre un bloc de lancer qui fait référence au bloc de capture, il arrête l'exécution et saute vers le bloc de capture.

Utilisons un exemple pour illustrer ce concept. Considérez la nidification désordonnée indiquée dans le code ci-dessous:

catch (: kill_me_now) faire
langs = ["python", "ruby", "c ++", "c #"]
foiinlangsdo
pour l'index en 1… 5
Si index == 3
ifi == "C #"
met "après lancer, rien ne fonctionnera!'"
lancer (: kill_me_now)
met "je suis c #"
fin
fin
fin
fin
fin
met "oh boy! C'était long!"

Nous commençons par utiliser le mot clé Catch et passons l'étiquette à l'intérieur d'une paire de parenthèses. Une fois que nous exécuterons le code, il exécutera toutes les boucles imbriquées et si les instructions jusqu'à ce qu'elle rencontre la déclaration de lancer faisant référence à la capture.

Qui fera fin immédiatement d'exécuter et de revenir au niveau de l'instruction Catch.

Voici un exemple de sortie:

Après le lancer, rien ne fonctionnera!'
Oh mec! C'était long!

Conclusion

Ce tutoriel vous a montré comment implémenter la gestion des erreurs dans Ruby à l'aide des blocs Raisse et Rescue.