L'interface error

Fait partie de la section Programmation Orientée Objet du Journey GO de Coddy — leçon 52 sur 107.

En Go, les erreurs sont gérées via une interface intégrée appelée error. Cette interface est remarquablement simple — elle ne nécessite qu'une seule méthode :

type error interface {
    Error() string
}

Tout type qui implémente une méthode Error() retournant une chaîne de caractères satisfait automatiquement l'interface error. C'est le système d'interface de Go à l'œuvre — aucune déclaration explicite n'est nécessaire.

La manière la plus courante de créer des erreurs est d'utiliser le package errors :

import "errors"

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

Les fonctions Go retournent généralement une erreur comme dernière valeur de retour. Lorsqu'aucune erreur ne se produit, vous retournez nil. L'appelant vérifie ensuite si l'erreur est non-nulle avant de continuer :

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

Vous pouvez également utiliser fmt.Errorf pour créer des messages d'erreur formatés :

func GetUser(id int) (string, error) {
    if id <= 0 {
        return "", fmt.Errorf("invalid user id: %d", id)
    }
    return "Alice", nil
}

Ce modèle consistant à retourner des erreurs plutôt qu'à lever des exceptions est fondamental en Go. Cela rend la gestion des erreurs explicite et vous oblige à considérer ce qui se passe quand les choses tournent mal — un aspect clé de l'écriture d'un code robuste et orienté objet.

Défi

Facile

Construisons un système de compte bancaire qui illustre le modèle de gestion des erreurs de Go. Vous allez créer un compte simple qui valide les opérations et renvoie des erreurs explicites en cas de problème.

Vous organiserez votre code sur deux fichiers :

account.go : Créez une structure BankAccount avec un champ exporté Owner (string) et un champ non exporté balance (float64). Implémentez les éléments suivants :
- NewBankAccount(owner string, initialDeposit float64) (*BankAccount, error) - un constructeur qui renvoie une erreur avec le message "initial deposit must be positive" si le dépôt initial est nul ou négatif. Sinon, créez et renvoyez le compte.
- Deposit(amount float64) error - ajoute de l'argent au solde. Renvoie une erreur avec le message "deposit amount must be positive" si le montant est nul ou négatif.
- Withdraw(amount float64) error - retire de l'argent du solde. Renvoie une erreur avec le message "withdrawal amount must be positive" si le montant est nul ou négatif, ou "insufficient funds" si le solde est inférieur au montant du retrait.
- Balance() float64 - renvoie le solde actuel
main.go : Lit les détails du compte et les montants des transactions à partir de l'entrée. Tente de créer un compte et d'effectuer des opérations. Après chaque opération, affiche soit le message de succès, soit le message d'erreur.

Les entrées suivantes seront fournies :

Ligne 1 : Nom du propriétaire (Owner name)
Ligne 2 : Montant du dépôt initial
Ligne 3 : Montant du dépôt
Ligne 4 : Montant du retrait

Pour chaque opération, affichez le résultat :

Après la création du compte : Account created for [Owner] with balance: $[balance] ou Error: [error message]
Après le dépôt : Deposited successfully. New balance: $[balance] ou Error: [error message]
Après le retrait : Withdrew successfully. New balance: $[balance] ou Error: [error message]

Formatez toutes les valeurs de solde avec deux décimales. Si la création du compte échoue, ignorez les opérations restantes.

Par exemple, avec Alice, 100, 50, et 200, votre sortie devrait être :

Account created for Alice with balance: $100.00
Deposited successfully. New balance: $150.00
Error: insufficient funds

Et avec Bob, -50, 25, et 10, votre sortie devrait être :

Error: initial deposit must be positive

Aide-mémoire

Go gère les erreurs via l'interface intégrée error, qui nécessite une seule méthode :

type error interface {
    Error() string
}

Créez des erreurs en utilisant le package errors :

import "errors"

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

Les fonctions retournent les erreurs comme dernière valeur de retour. Retournez nil lorsqu'aucune erreur ne survient :

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

Utilisez fmt.Errorf pour les messages d'erreur formatés :

func GetUser(id int) (string, error) {
    if id <= 0 {
        return "", fmt.Errorf("invalid user id: %d", id)
    }
    return "Alice", nil
}

Essayez vous-même

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	reader := bufio.NewReader(os.Stdin)

	// Lire le nom du propriétaire
	ownerName, _ := reader.ReadString('\n')
	ownerName = strings.TrimSpace(ownerName)

	// Lire le dépôt initial
	initialDepositStr, _ := reader.ReadString('\n')
	initialDeposit, _ := strconv.ParseFloat(strings.TrimSpace(initialDepositStr), 64)

	// Lire le montant du dépôt
	depositStr, _ := reader.ReadString('\n')
	depositAmount, _ := strconv.ParseFloat(strings.TrimSpace(depositStr), 64)

	// Lire le montant du retrait
	withdrawStr, _ := reader.ReadString('\n')
	withdrawAmount, _ := strconv.ParseFloat(strings.TrimSpace(withdrawStr), 64)

	// TODO: Créer un nouveau compte bancaire en utilisant NewBankAccount
	// S'il y a une erreur, afficher "Error: [error message]" et retourner
	// En cas de succès, afficher "Account created for [Owner] with balance: $[balance]"

	// TODO: Tenter de déposer le montant du dépôt
	// S'il y a une erreur, afficher "Error: [error message]"
	// En cas de succès, afficher "Deposited successfully. New balance: $[balance]"

	// TODO: Tenter de retirer le montant du retrait
	// S'il y a une erreur, afficher "Error: [error message]"
	// En cas de succès, afficher "Withdrew successfully. New balance: $[balance]"

	// N'oubliez pas de formater les valeurs de solde avec deux décimales en utilisant fmt.Printf("%.2f", balance)

	_ = ownerName
	_ = initialDeposit
	_ = depositAmount
	_ = withdrawAmount
}