Gestion de base des erreurs

Fait partie de la section Fondamentaux du Journey GO de Coddy — leçon 108 sur 109.

La gestion de base des erreurs est un modèle fondamental en Go, où vous vérifiez les erreurs après des opérations susceptibles d'échouer.

Apprenons à gérer les erreurs en Go en créant une fonction de division simple qui renvoie une erreur lors d'une division par zéro :

func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

Cette fonction renvoie deux valeurs : le résultat de la division et une erreur. Si le diviseur est zéro, elle renvoie un message d'erreur au lieu de tenter la division.

Voyons maintenant comment utiliser cette fonction et gérer les erreurs potentielles :

result, err := divide(10, 0)
    
if err != nil {
    fmt.Println("Error occurred:", err)
    return // Arrêter l'exécution ou gérer l'erreur
}
    
fmt.Println("Result:", result)

Après l'exécution de ce code, nous vérifions si une erreur s'est produite en utilisant la condition if err != nil. Comme nous avons essayé de diviser par zéro, la fonction renvoie une erreur, et ce qui suit s'affichera à l'écran :

Error occurred: division by zero

Ce modèle consistant à retourner une erreur comme dernière valeur de retour et à la vérifier immédiatement est très courant en Go. Cela permet à votre programme de gérer les échecs de manière élégante au lieu de planter.

Défi

Facile

Dans ce défi, vous allez pratiquer la gestion d'erreurs de base en Go. Vous avez une fonction qui divise deux nombres, mais la division par zéro provoque une erreur d'exécution. Votre tâche consiste à ajouter une gestion d'erreurs pour éviter ce plantage.

Le code possède déjà une fonction qui renvoie à la fois un résultat et une erreur. Vous devez vérifier s'il y a une erreur avant d'utiliser le résultat.

Aide-mémoire

En Go, les fonctions susceptibles d'échouer renvoient une erreur comme dernière valeur de retour :

func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

Vérifiez les erreurs en utilisant if err != nil :

result, err := divide(10, 0)
    
if err != nil {
    fmt.Println("Error occurred:", err)
    return // Arrêter l'exécution ou gérer l'erreur
}
    
fmt.Println("Result:", result)

Ce modèle permet aux programmes de gérer les défaillances de manière élégante au lieu de planter.

Essayez vous-même

package main

import (
	"errors"
	"fmt"
)

// Cette fonction divise x par y et retourne une erreur si y est égal à zéro
func divide(x, y float64) (float64, error) {
	if y == 0 {
		return 0, errors.New("cannot divide by zero")
	}
	return x / y, nil
}

func main() {
	// Valeurs de test
	numerator := 10.0
	denominator := 0.0
	
	// Appeler la fonction divide
	result, err := divide(numerator, denominator)
	
	// TODO : Vérifier si err n'est pas nil (il y a une erreur)
	// S'il y a une erreur, l'afficher en utilisant fmt.Println(err)
	// Sinon, afficher le résultat en utilisant fmt.Printf("Result: %.2f\n", result)
	
	// Supprimer cette ligne et implémenter une gestion d'erreur appropriée ci-dessus
	fmt.Printf("Result: %.2f\n", result)
}