Go est un langage de programmation très apprécié qui a gagné en popularité en raison de son efficacité, de sa rapidité et de son efficience. Cependant, des erreurs peuvent se produire pendant les phases de développement et d'exécution, comme avec tout autre langage de programmation. La gestion efficace des erreurs est essentielle pour assurer la fiabilité et la stabilité de vos programmes Go.
Cet article examine plusieurs méthodes et procédures recommandées pour gérer les erreurs dans Go.
Gérer les erreurs dans Golang
Dans Go, vous pouvez gérer les erreurs par les méthodes ci-dessous :
- Fonction Nouveau()
- Fonction Erreurf()
- Gestion explicite des erreurs
- Différer, paniquer et récupérer
- Emballage d'erreur
1 : Fonction Nouveau()
Le langage Go fournit la Nouveau() fonction de gestion des erreurs. Cette fonction, disponible dans le package d'erreurs intégré, permet aux développeurs de créer des messages d'erreur personnalisés pour leurs programmes. En utilisant le Nouveau() fonction, les développeurs peuvent gérer efficacement les erreurs et fournir des messages d'erreur significatifs aux utilisateurs.
paquet principal
importer 'les erreurs'
importer 'fmt'
vérification des fonctions ( chaîne de nom ) erreur {
nError := erreurs.Nouveau ( 'Nom incorrect' )
si nom ! = 'Linux' {
retour nErreur
}
retour néant
}
fonction principale ( ) {
nom := 'Linux'
erreur := vérifier ( nom )
si se tromper ! = nul {
fmt.Println ( se tromper )
} autre {
fmt.Println ( 'Nom valide' )
}
}
Le code ci-dessus utilise le Nouveau() checkName fonction pour voir si la chaîne Linux correspond au nom donné. La fonction produit une erreur avec le message Nom incorrect si le nom n'est pas Linux . La fonction renvoie nil pour montrer qu'il n'y a pas eu d'erreur si le nom est égal à Linux .
La variable de nom est définie sur Linux dans l'appel de la fonction main à la checkName fonction, qui prend également la variable name comme argument. La fonction main imprime le message d'erreur si le checkName fonction renvoie une erreur. La fonction principale imprime le Nom valide si la checkName la fonction renvoie nil.
Sortir
2 : Fonction Erreurf()
Le Erreurf() La fonction dans Go nous permet également de gérer les erreurs. Erreurf() nous donne la possibilité de formater le message d'erreur. En important le package fmt, les développeurs peuvent l'utiliser pour personnaliser les messages d'erreur en fonction de leurs besoins. Erreurf() rationalise et améliore l'efficacité de la gestion et de la transmission des erreurs dans Go.
paquet principalimporter 'fmt'
fonction div ( n1, n2 vous ) erreur {
si n2 == 0 {
retour fmt.Errorf ( '%d / %d \n Impossible de diviser un nombre par zéro' , n1, n2 )
}
retour néant
}
fonction principale ( ) {
erreur := div ( 42 , 0 )
si se tromper ! = nul {
fmt.Printf ( 'les erreurs' , erreur )
} autre {
fmt.Println ( 'Division valide' )
}
}
Dans le code ci-dessus, le div La fonction accepte deux entrées entières, n1 et n2, et si n2 est égal à zéro, elle produit une erreur. La fonction produit une erreur avec un message qui contient les valeurs de n1 et n2 si n2 est égal à zéro. La fonction renvoie nil pour montrer qu'il n'y a pas eu d'erreur si n2 n'est pas nul.
L'erreur renvoyée par div est enregistrée dans la variable err lorsque la fonction main exécute div avec les valeurs 42 et 0. La fonction main utilise fmt.Printf pour afficher le message d'erreur si la fonction div renvoie une erreur. La fonction principale imprime Division valide si la fonction div renvoie nil.
Sortir
3 : Gestion explicite des erreurs
Go encourage la gestion explicite des erreurs par rapport aux autres langages de programmation, qui reposent souvent sur des exceptions. Cette approche encourage les développeurs à utiliser des instructions if pour vérifier explicitement les erreurs, au lieu de s'appuyer sur des blocs try-catch. Ce faisant, les erreurs sont plus susceptibles d'être trouvées et corrigées correctement. Pour faciliter cela, Go fournit le si err != néant , qui permet aux développeurs de vérifier les erreurs après l'exécution d'une fonction et de prendre les mesures appropriées en fonction du résultat. Avec une gestion explicite des erreurs, Go offre une approche plus structurée et plus fiable de la gestion des erreurs.
paquet principalimporter 'fmt'
division de fonction ( un, b float64 ) ( float64, erreur ) {
si b == 0 {
retour 0 , fmt.Errorf ( 'impossible de diviser par zéro' )
}
retour un / b, néant
}
fonction principale ( ) {
résultat, err := diviser ( 13 , 3 )
si se tromper ! = nul {
fmt.Printf ( 'Erreur : %v \n ' , erreur )
} autre {
fmt.Printf ( 'Résultat : %f \n ' , résultat )
}
résultat, erreur = diviser ( 23 , 0 )
si se tromper ! = nul {
fmt.Printf ( 'Erreur : %v \n ' , erreur )
} autre {
fmt.Printf ( 'Résultat : %f \n ' , résultat )
}
}
Dans cette illustration, la fonction de division est utilisée pour diviser deux valeurs. La sortie est le résultat de le faire. Si le deuxième nombre est 0, la fonction produit une erreur avec un message d'erreur distinct.
Divide est appelée deux fois dans la fonction main : une fois avec des entrées valides et une fois avec des entrées invalides. Le, si erreur != néant est utilisée pour déterminer si une erreur s'est produite chaque fois que la fonction de division est utilisée. Un message d'erreur est imprimé le cas échéant. Sinon, le résultat est imprimé.
Sortir
4 : Différer, paniquer et récupérer
Golang fournit également le reporter instruction, qui est utilisée pour exécuter une fonction après l'achèvement d'un programme ou d'un bloc de code spécifique. Le reporter déclaration est souvent utilisée en conjonction avec la récupérer fonction pour attraper et récupérer des erreurs de panique d'exécution. Lorsqu'une erreur de panique d'exécution se produit, le récupérer La fonction est utilisée pour récupérer de la condition d'erreur et empêcher le programme de planter. Ceci est utile pour les tâches de nettoyage telles que la fermeture de fichiers, la fermeture de connexions réseau ou la libération de ressources. En différant ces tâches, vous vous assurez qu'elles seront exécutées même si une erreur se produit.
Le panique est utilisé pour arrêter l'exécution normale du programme lorsqu'une erreur inattendue se produit, tandis que récupérer est utilisé pour gérer la panique et poursuivre l'exécution du programme.
paquet principalimporter 'fmt'
fonction recoveryFromPanic ( ) {
si r := récupérer ( ) ; r ! = nul {
fmt.Println ( « Remis de panique : » , r )
}
}
division de fonction ( x,y float64 ) float64 {
différer recoveryFromPanic ( )
si et == 0 {
panique ( 'impossible de diviser par zéro' )
}
retour X / et
}
fonction principale ( ) {
fmt.Println ( diviser ( 13 , 3 ) )
fmt.Println ( diviser ( 23 , 0 ) )
}
Dans le code ci-dessus, la fonction de division est utilisée pour diviser deux valeurs à virgule flottante. La sortie est le résultat de le faire. Un message d'erreur personnalisé est émis par la fonction si le deuxième nombre est zéro. L'instruction defer est utilisée pour invoquer le récupérerDePanique fonction. Le récupérerDePanique détectera une panique qui s'est produite à l'intérieur de la fonction de division et affichera une erreur si cela s'est produit.
Divide est appelée deux fois dans la fonction main : une fois avec des entrées valides et une fois avec des entrées invalides. Le fmt.Println fonction imprime la sortie de la fonction chaque fois que la fonction de division est exécutée. Le récupérerDePanique détectera une panique si cela se produit et imprimera une erreur si c'est le cas.
Sortir
Après avoir détecté l'erreur, le programme s'est remis de la panique et a continué à fonctionner. Cependant, le code a paniqué et n'a pas renvoyé de valeur lors du deuxième appel à diviser, c'est pourquoi il a renvoyé zéro.
5 : Emballage d'erreur
Go comprend également une fonctionnalité appelée Erreur d'habillage , qui vous permet d'ajouter un contexte supplémentaire à un message d'erreur. Ceci est utile pour enregistrer les problèmes ou fournir des détails supplémentaires dans les messages d'erreur. Cela peut être accompli en créant un type d'erreur qui intègre l'erreur d'origine et un contexte supplémentaire.
paquet principalimporter 'les erreurs'
importer 'fmt'
fonction principale ( ) {
si erreur := barre ( ) ; se tromper ! = nul {
fmt.Println ( se tromper )
}
}
division de fonction ( un, b float64 ) ( float64, erreur ) {
si b == 0 {
retour 0 , erreurs.Nouveau ( 'division par zéro' )
}
retour un / b, néant
}
barre de fonction ( ) ( erreur erreur ) {
_, err = diviser ( 42 , 0 )
si se tromper ! = nul {
retour fmt.Errorf ( 'échec du calcul : %w' , erreur )
}
retour néant
}
Dans le code ci-dessus, la fonction de division calcule le rapport de deux nombres dans cet exemple et génère une erreur si la deuxième valeur est zéro. La fonction bar appelle la fonction de division, puis encapsule l'erreur qui diviser renvoie une nouvelle erreur avec un message incluant le message d'erreur d'origine à l'aide de la fonction fmt.Errorf. La fonction bar est appelée par la fonction main, qui imprime également toutes les erreurs qu'elle renvoie.
Sortir
Conclusion
Le développement logiciel doit inclure la gestion des erreurs , et Golang a diverses fonctions et méthodes intégrées pour le faire avec élégance. Ces mécanismes permettent aux développeurs d'intercepter et de récupérer des erreurs, d'empêcher les pannes de programme et de fournir des messages d'erreur informatifs aux utilisateurs finaux. En utilisant efficacement ces mécanismes de gestion des erreurs, les développeurs peuvent créer des applications logicielles robustes, fiables et efficaces.