La gestion des erreurs est l'une des opérations fréquentes dans le cycle de développement logiciel. C’est un aspect crucial d’une bonne programmation. Go adopte une approche simple et facile à utiliser avec son mécanisme intégré de gestion des erreurs. Il est basé sur le renvoi d'erreurs à partir de fonctions et de méthodes, ce qui vous permet de vous concentrer sur une fonctionnalité de code intuitive et facile à lire.
Vous gérez explicitement les erreurs dans Go, ce qui se traduit par un cadre solide pour les commentaires, avec la possibilité d'implémenter une logique de nouvelle tentative de manière cohérente. Le les erreurs package fournit des fonctionnalités supplémentaires pour la gestion des erreurs.
Le paquet d'erreurs
Le paquet d'erreurs est l'un des packages de la bibliothèque standard de Go. Le package fournit des primitives et des fonctionnalités simples de gestion des erreurs pour créer et manipuler des erreurs de manière cohérente dans le code Go.
Le forfait fournit le Nouveau fonction pour créer des erreurs avec des messages d'erreur personnalisés que vous pouvez utiliser de la même manière que n'importe quel type d'erreur intégré, tel que le néant et Erreur méthode de la erreur interface.
Le les erreurs package fournit également des fonctionnalités pour envelopper et désenvelopper les erreurs, une méthode pour les assertions de type sur les erreurs.
Vous pouvez importer le les erreurs package avec le mot-clé import. Indiquez simplement le nom du colis dans votre liste d'imports.
importer"les erreurs"
Capture et gestion des erreurs dans Go
La connaissance de la gestion des erreurs de base dans Go jette les bases pour comprendre le les erreurs emballer. Les fonctions et les méthodes renvoient des erreurs accompagnées d'une ressource.
Voici un exemple de gestion d'erreur à partir d'une opération d'ouverture de fichier avec la fonction intégrée os emballer.
emballer principalimporter (
"fmt"
"os"
)fonctionprincipal() {
fichier, erreur := os. Ouvrir("nomfichier.txt")si erreur != néant {
fmt. Println (erreur)
}
// ...
}
Le Ouvrir méthode de la os package est utile lorsque travailler avec des fichiers texte dans Go. Il ouvre un fichier, renvoyant une instance de fichier ouvert et un erreur.
La valeur d'erreur peut être le néant type, indiquant qu'il n'y a pas d'erreur. Cependant, vous pouvez rechercher un cas non nul et gérer une erreur si elle est présente. Dans le cas ci-dessus, le bloc if affiche l'erreur.
Vous pouvez accéder au Erreur méthode d'une erreur pour extraire plus d'informations sur l'erreur (généralement une description).
si erreur != néant {
fmt. Println (err. Erreur())
}
Par exemple, si le fichier n'existe pas, vous verrez un message d'erreur qui ressemble à ceci :
Création d'erreurs dans Go
Vous pouvez créer des erreurs avec le Nouveau méthode de la les erreurs emballer. Cette méthode prend un message de chaîne et renvoie les erreurs rencontrées.
importer"les erreurs"fonctionprincipal() {
erreur := erreurs. Nouveau("quelque chose s'est mal passé")
si erreur != néant {
// le code de gestion des erreurs va ici
}
}
Le principal La fonction crée une nouvelle erreur et gère les erreurs possibles à partir de la création d'erreur avec un si déclaration.
Vous pouvez également définir des erreurs personnalisées dans Go. La méthode conventionnelle utilise une structure et une fonction d'erreur pour implémenter la structure basée sur la fonctionnalité de l'erreur.
emballer principalimporter"fmt"
taper erreur personnalisée structure {
Info chaîne
}fonctionprincipal() {
// exemple d'instanciation de la structure
erreur := erreur personnalisée{
Info: "Quelque chose s'est mal passé !",
}
// affiche l'instance de la structure
fmt. Println (erreur)
}
Le erreur personnalisée struct est le modèle de l'erreur, et le Info le champ de chaîne contiendra le message d'erreur.
Vos fonctions d'erreur peuvent implémenter le erreur personnalisée struct et renvoie une chaîne d'erreur.
fonction(ce customError)Erreur()chaîne {
retour fmt. Sprintf("Une erreur personnalisée s'est produite: %v", ce.info)
}
Le Erreur méthode de la erreur personnalisée struct renvoie une chaîne en utilisant la méthode de formatage Sprintf du package fmt.
Erreurs d'emballage et de déballage dans Go
Vous pouvez ajouter d'autres informations contextuelles aux erreurs en les enveloppant. Vous utiliserez principalement des erreurs enveloppées pour créer des messages d'erreur clairs pour la précision du débogage.
Vous pouvez utiliser le Erreurf méthode de la fmt package qui fournit des fonctionnalités de formatage des messages d'erreur pour envelopper les erreurs. Le Erreurf La méthode prend une chaîne et un verbe de formatage de chaîne et l'erreur et renvoie l'erreur encapsulée.
importer (
"fmt"
"os"
)fonctionprincipal() {
_, euh := os. Ouvrir("nomfichier.txt")
si erreur != néant {
enveloppéErr := fmt. Erreurf("Erreur lors de l'ouverture du fichier: %v", euh)
fmt. Println (wrappedErr)
}
}
Le principal La fonction ouvre un fichier avec le os paquets Ouvrir et encapsule l'erreur avec la méthode Errorf de la fmt emballer. Il affiche ensuite l'erreur encapsulée dans la console.
Vous pouvez déballer les erreurs encapsulées dans vos programmes avec le Déballer méthode de la les erreurs emballer. Le Déballer La méthode prend l'erreur encapsulée et renvoie l'erreur non encapsulée.
importer (
"fmt"
"os"
"les erreurs"
)fonctionprincipal() {
_, euh := os. Ouvrir("nomfichier.txt")
si erreur != néant {
enveloppéErr := fmt. Erreurf("Erreur lors de l'ouverture du fichier: %v", euh)
unwrappedErr := erreurs. Déballer (wrappedErr)
fmt. Println (Err non emballé)
}
}
Le principal la fonction enveloppe une erreur d'une opération d'ouverture de fichier, et la déballéErr La variable contient l'erreur non encapsulée.
Enregistrez vos rapports d'erreurs avec ces packages de journalisation tiers
Vous devrez consigner certaines erreurs pour les révisions ultérieures, le débogage et d'autres opérations au cours du processus de développement de votre application. Vous pouvez utiliser le zapper package par les packages Uber, Logrus, Zerolog et Log15 pour une journalisation rapide et structurée.