Les bases de la gestion des erreurs de Golang

L’une des caractéristiques les plus utiles du langage de programmation Go est la façon dont il gère les erreurs. Au lieu d’utiliser une méthodologie Try/Catch comme d’autres langages de programmation, Go traite les erreurs comme des valeurs de retour normales.

En créant des modules simples et en appliquant quelques règles de journalisation, nous pouvons produire des messages d’erreur utiles pour attraper toutes sortes d’exceptions au cours du processus de développement.

Dans cet article, nous allons couvrir certaines des façons les plus basiques dont Golang trouve et traite ces exceptions.

Golang Basic Error Handling

Nous pouvons capturer des erreurs dans Go en utilisant de simples instructions if/then qui vérifient les conditions dans lesquelles les paramètres requis ne sont pas remplis.

Regardons un module de base que nous pouvons créer pour vérifier si une chaîne de caractères comprend une valeur ou non.

Créons un package nommé « hello » et importons les modules standards « errors » et « fmt » pour reconnaître les erreurs et le texte formaté :

package helloimport ("errors""fmt")

Puis nous pouvons créer un module qui retournera une chaîne de texte pour une variable nommée.

func Hello(name string) (string, error) {if name == "" {return "", errors.New("No name was given")}

Le module ci-dessus vérifie si une chaîne vide est renvoyée pour la variable « nom », qui renvoie ensuite une nouvelle erreur avec un certain texte spécifié. C’est notre condition d’erreur. Une condition d’erreur vérifie si l’erreur elle-même existe.
Si la condition n’est pas remplie (c’est-à-dire qu’il n’y a pas d’erreur), nous retournons la valeur qui correspond à la variable « name » spécifiée:

message := fmt.Sprintf("Hi, %v. Welcome!", name)return message, nil}

Notez qu’elle retourne le message et la valeur « nil », ce qui signifie qu’il n’y a pas d’erreur. Cela indique au programme appelant que la fonction s’est traitée sans erreur.

Nous allons maintenant voir comment nous pouvons appeler ce paquet dans un script réel.

Créons un nouveau script, appelé test.go

Comme il est normal avec Golang, un script doit commencer par définir le paquetage comme « main ». Nous importons ensuite les paquets « fmt » et « log », ainsi que notre paquet « hello » créé, comme indiqué ci-dessous:

package mainimport ("fmt""log""yoursite.com/hello")

Vous trouverez ci-dessous la définition de notre fonction principale, la définition de quelques propriétés pour notre logger afin de créer un préfixe facile à comprendre, et (pour des raisons de sécurité) la création d’un drapeau afin de ne pas afficher l’heure, le fichier source et le numéro de ligne.

func main() {log.SetPrefix("Hello: ")log.SetFlags(0)

Puis, nous allons spécifier un message à afficher :

message, err := hello.Hello("")

Enfin, nous cherchons à savoir s’il y a une erreur en vérifiant si « err » n’est pas égal à « nil ». Si c’est le cas, nous imprimons le message sur la console et sortons.

if err != nil {log.Fatal(err)}

Si aucune condition d’erreur n’existe, nous imprimons simplement le message qui a été défini dans notre paquet hello.

fmt.Println(message)}

Pour tester cela, nous pouvons exécuter le code tel quel. Une fois que nous l’avons fait, nous devrions obtenir un résultat qui ressemble à ceci:

>go run test.gogreetings: No name was givenexit status 1

Si nous souhaitons modifier notre script test.go, entrez quelque chose comme ceci :

message, err := hello.Hello("John")

Notre sortie devrait alors ressembler à ceci:

>go run test.goHi, John. Welcome!

Un autre type de message d’erreur que nous pouvons retourner est:

fmt.Errorf – ceci va formater une chaîne de caractères selon les règles de Printf.

Gestion des entiers dans Golang

Bien sûr, les erreurs de chaîne de caractères ne sont qu’un type d’erreur. Avec la gestion des erreurs de Golang, il existe plusieurs autres erreurs que vous pouvez vérifier dans votre code. Il y en a une en particulier que vous devez connaître : les erreurs numériques.

La gestion des nombres entiers est simple pour Go. Voici comment cela fonctionne :

Disons que nous avons des erreurs numériques, comme si nous devions diviser par zéro. Nous créons d’abord une fonction « Division », qui divise deux variables x par y. Pour la première partie de notre condition if/then, nous devons nous assurer que y n’est pas égal à zéro :

func Division(x int, y int) (int, error) {if y == 0 {return 0, errors.New("Thou shalt not divide by zero!")} else {return (x / y), nil}}

C’est la fonction principale. Maintenant, vous pouvez lui passer deux variables. Dans cet exemple, nous utiliserons 12 et 0.

func main() {if result, err := Division(12, 0); err != nil {fmt.Println("We got an error: ", err)} else {fmt.Println("The answer is", result)}}

Vous recevrez alors un message qui dira quelque chose comme :

« Nous avons obtenu une erreur : Tu ne diviseras pas par zéro ! »

Ce n’est qu’un exemple de la façon dont vous pouvez utiliser la gestion des erreurs de Golang pour trouver des erreurs numériques. Vraiment, avec les bonnes fonctions, vous pouvez trouver plusieurs erreurs par vous-même via Golang.

Trouver les erreurs d’état HTTP

Avec Golang, vous pouvez faire apparaître les erreurs d’état HTTP si une API que nous appelons en délivre une.

Voici comment :

Premièrement, importons un nouveau package, « net/http »:

import ( "fmt" "log" "net/http")

Dans notre fonction principale, appelons une application (par exemple un site Web) et consignons les éventuelles erreurs. Nous savons que les requêtes réussies se situent dans la plage 2xx, alors créez un statut respectif qui trouve toutes les erreurs HTTP qui se situent en dehors de cette plage. Vous pouvez le faire de la manière suivante :

func main() { resp, err := http.Get("https://example.com") if err != nil { log.Fatal(err) } fmt.Println("HTTP Response Status:", resp.StatusCode, http.StatusText(resp.StatusCode)) if resp.StatusCode >= 200 && resp.StatusCode 

Comme vous pouvez le voir, notre fonction principale est définie sur

>= 200 && resp.StatusCode <= 299

qui vérifiera si toute demande HTTP relève de la plage 2xx. Si la requête ne remplit pas cette condition, il affichera un message d’erreur.

Avec un seul module, vous pouvez rapidement rassembler toutes les informations dont vous avez besoin pour trouver et corriger votre code Golang.

Résumé

Ce guide ne fait qu’effleurer la façon dont le langage Go est conçu pour gérer les erreurs. Cependant, des bases telles que la façon de vérifier l’existence d’une chaîne de caractères, la façon de lever une condition d’erreur si une instruction numérique illogique est présentée, et la façon de vérifier les codes d’état HTTP d’une réponse sont tous d’excellents endroits pour commencer votre voyage de surveillance des erreurs Golang.

Vous n’avez pas le temps de vérifier et d’utiliser ces techniques de gestion des erreurs Golang manuellement ? C’est là que des outils comme Airbrake Error Monitoring s’avèrent utiles. Avec Airbrake Error Monitoring, vous serez en mesure de trouver des erreurs rapidement sans avoir besoin de créer des modules individuels. Essayez gratuitement Airbrake Error Monitoring pendant 30 jours pour un nombre illimité d’erreurs et d’événements de performance.