Interfaces Stringer et Error

Fait partie de la section Programmation Orientée Objet du Journey GO de Coddy. Leçon 32 sur 107.

La bibliothèque standard de Go définit deux interfaces que vous utiliserez constamment : fmt.Stringer et error. Toutes deux sont des interfaces simples à méthode unique qui offrent à vos types une intégration puissante avec les fonctionnalités intégrées de Go.

L’interface Stringer se trouve dans le package fmt et ne requiert qu’une seule méthode :

type Stringer interface {
    String() string
}

Lorsque vous implémentez String() sur votre type, des fonctions comme fmt.Println l'utilisent automatiquement pour afficher votre valeur :

type Person struct {
    Name string
    Age  int
}

func (p Person) String() string {
    return fmt.Sprintf("%s (%d years old)", p.Name, p.Age)
}

func main() {
    p := Person{Name: "Alice", Age: 30}
    fmt.Println(p)  // Alice (30 ans)
}

L’interface error est tout aussi simple : elle requiert une méthode Error() qui renvoie une chaîne de caractères :

type error interface {
    Error() string
}

Tout type possédant une méthode Error() peut être utilisé comme une valeur d'erreur en Go. Cela vous permet de créer des types d'erreurs personnalisés avec un contexte supplémentaire :

type ValidationError struct {
    Field   string
    Message string
}

func (e ValidationError) Error() string {
    return fmt.Sprintf("%s: %s", e.Field, e.Message)
}

func main() {
    err := ValidationError{Field: "email", Message: "invalid format"}
    fmt.Println(err)  // email: format invalide
}

Ces deux interfaces démontrent la philosophie de Go : des interfaces petites et ciblées qui débloquent des comportements puissants grâce à l'implémentation implicite.

Défi

Facile

Construisons un système de surveillance de la température qui utilise à la fois les interfaces Stringer et error afin de fournir un affichage lisible et une gestion pertinente des erreurs.

Vous organiserez votre code sur deux fichiers :

temperature.go : créez une structure Temperature avec les champs Value (float64) et Unit (string). Implémentez la méthode String() afin que, lors de l’affichage, elle présente la température dans un format lisible. Créez également une structure TemperatureError avec les champs Temp (float64) et Reason (string), puis implémentez la méthode Error() pour fournir des messages d’erreur descriptifs.
main.go : créez une fonction appelée ValidateTemperature qui accepte une Temperature et renvoie une erreur si la température n’est pas valide. Une température n’est pas valide si elle est inférieure au zéro absolu (-273.15 pour Celsius, -459.67 pour Fahrenheit). Si elle est valide, la fonction renvoie nil. Lisez les données de température depuis l’entrée, créez une Temperature, validez-la, puis affichez le résultat approprié.

Les entrées suivantes seront fournies :

Ligne 1 : valeur de la température (float)
Ligne 2 : unité (C pour Celsius ou F pour Fahrenheit)

Votre méthode String() doit renvoyer le format suivant :

[Value] degrees [Unit]

Où Unit est le mot complet « Celsius » ou « Fahrenheit » selon l’entrée.

Votre méthode Error() doit renvoyer le format suivant :

invalid temperature [Temp]: [Reason]

Si la température est valide, affichez la Temperature avec fmt.Println (ce qui utilisera votre méthode String()). Si elle n’est pas valide, affichez l’erreur (ce qui utilisera votre méthode Error()).

Par exemple, avec 25.5 et C, votre sortie doit être :

25.5 degrees Celsius

Avec -500 et F, votre sortie doit être :

invalid temperature -500: below absolute zero

Utilisez "below absolute zero" comme raison lorsque la température est trop basse.

Essayez vous-même

package main

import (
	"fmt"
)

// ValidateTemperature vérifie si une température est valide
// Retourne une erreur si la température est inférieure au zéro absolu
// Zéro absolu : -273.15 pour Celsius, -459.67 pour Fahrenheit
func ValidateTemperature(t Temperature) error {
	// TODO: Implémenter la logique de validation
	// Vérifier si la température est inférieure au zéro absolu selon l'unité
	// Retourner une TemperatureError si invalide, nil si valide
	return nil
}

func main() {
	var value float64
	var unit string
	fmt.Scanln(&value)
	fmt.Scanln(&unit)

	// TODO: Créer une structure Temperature avec les valeurs d'entrée

	// TODO: Valider la température en utilisant ValidateTemperature

	// TODO: S'il y a une erreur, afficher l'erreur
	// Sinon, afficher la température (qui utilisera la méthode String())
}