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 par l’intermédiaire d’une interface intégrée appelée error. Cette interface est remarquablement simple. Elle ne requiert qu’une seule méthode :

type error interface {
    Error() string
}

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

La manière la plus courante de créer des erreurs consiste à 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 renvoient généralement une erreur comme dernière valeur de retour. Lorsqu’aucune erreur ne se produit, vous renvoyez nil. L’appelant vérifie ensuite si l’erreur n’est pas 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 à renvoyer des erreurs plutôt qu’à lever des exceptions est fondamental en Go. Il rend la gestion des erreurs explicite et vous force à réfléchir à ce qui se passe lorsque les choses tournent mal : un aspect essentiel 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 lorsque quelque chose ne va pas.

Vous organiserez votre code sur deux fichiers :

account.go : créez une structure BankAccount avec un champ Owner exporté (string) et un champ balance non exporté (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. Renvoyez 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. Renvoyez 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 : lisez les informations du compte et les montants des transactions depuis l'entrée. Essayez de créer un compte et d'effectuer les opérations. Après chaque opération, affichez soit le message de réussite, soit le message d'erreur.

Les entrées suivantes seront fournies :

Ligne 1 : nom du propriétaire
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 doit ê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 doit être :

Error: initial deposit must be positive

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)

	// Read initial deposit
	initialDepositStr, _ := reader.ReadString('\n')
	initialDeposit, _ := strconv.ParseFloat(strings.TrimSpace(initialDepositStr), 64)

	// Read deposit amount
	depositStr, _ := reader.ReadString('\n')
	depositAmount, _ := strconv.ParseFloat(strings.TrimSpace(depositStr), 64)

	// Read withdrawal amount
	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]"
	// If successful, print "Deposited successfully. New balance: $[balance]"

	// TODO: Tenter de retirer le montant du retrait
	// S'il y a une erreur, afficher "Error: [error message]"
	// If successful, print "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
}