Le concept d'erreur

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

En Go, les erreurs sont des valeurs qui indiquent que quelque chose s'est mal passé. Go gère les erreurs de manière explicite plutôt que d'utiliser des exceptions.

Créons une fonction qui pourrait produire une erreur lors de la division de nombres :

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

Cette fonction retourne deux valeurs : le résultat de la division et une erreur potentielle. Si le diviseur est égal à zéro, nous retournons un message d'erreur au lieu de tenter la division.

Maintenant, utilisons notre fonction et gérons les erreurs potentielles :

result, err := divide(10, 0)
if err != nil {
    fmt.Println("Error:", err)
} else {
    fmt.Println("Result:", result)
}

Après l'exécution de ce code, nous verrons un message d'erreur à l'écran car nous avons essayé de diviser par zéro :

Error: cannot divide by zero

Ceci illustre le modèle de gestion des erreurs de Go : vérifier si une erreur s'est produite (err != nil), puis prendre les mesures appropriées. Si aucune erreur ne s'est produite, nous pouvons utiliser le résultat en toute sécurité.

Défi

Facile

Dans ce défi, vous allez vous entraîner à manipuler les erreurs en Go. Vous allez créer une fonction qui divise deux nombres et renvoie une erreur si une division par zéro est tentée.

Votre tâche consiste à :

Compléter la fonction divide qui prend deux entiers et renvoie leur quotient et une erreur.
Si le diviseur est zéro, renvoyez 0 et une erreur avec le message "division by zero".
Si la division est valide, renvoyez le résultat et nil pour l'erreur.
Dans la fonction main, appelez divide avec les valeurs fournies et gérez les erreurs de manière appropriée.

Cet exercice démontre comment les fonctions Go renvoient couramment un résultat et une erreur, et comment vérifier et gérer ces erreurs.

Aide-mémoire

En Go, les erreurs sont des valeurs qui indiquent que quelque chose s'est mal passé. Go gère les erreurs de manière explicite plutôt que d'utiliser des exceptions.

Les fonctions susceptibles d'échouer retournent deux valeurs : le résultat et une erreur potentielle :

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

Pour gérer les erreurs, vérifiez si l'erreur n'est pas nil :

result, err := divide(10, 0)
if err != nil {
    fmt.Println("Error:", err)
} else {
    fmt.Println("Result:", result)
}

Utilisez errors.New() pour créer de nouveaux messages d'erreur et retournez nil lorsqu'aucune erreur ne se produit.

Essayez vous-même

package main
import (
    "errors"
    "fmt"
)
// divide divise a par b et retourne le résultat
// Si b est égal à 0, elle retourne une erreur
func divide(a, b int) (int, error) {
    // TODO: Implémenter la fonction divide
    // Si b est égal à 0, retourner 0 et une erreur avec le message "division by zero"
    // Sinon, retourner a/b et nil pour l'erreur

}
func main() {
    // Premier cas de test
    a, b := 10, 2
    result, err := divide(a, b)
    if err != nil {
        fmt.Printf("Error: %s\n", err)
    } else {
        fmt.Printf("Result: %d\n", result)
    }

    // Deuxième cas de test
    a, b = 8, 0
    result, err = divide(a, b)
    if err != nil {
        fmt.Printf("Error: %s\n", err)
    } else {
        fmt.Printf("Result: %d\n", result)
    }
}