Interfaces Stringer & 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 nécessite 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, nécessitant une méthode Error() qui retourne 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 pour fournir une sortie lisible et une gestion des erreurs significative.

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() de sorte que, lorsqu'elle est affichée, elle présente la température dans un format lisible par l'homme. Créez également une structure TemperatureError avec les champs Temp (float64) et Reason (string), et implémentez la méthode Error() pour fournir des messages d'erreur descriptifs.
main.go : Créez une fonction nommée ValidateTemperature qui prend une Temperature et renvoie une erreur si la température est invalide. Une température est invalide 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 et affichez la sortie appropriée.

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 retourner le format :

[Value] degrees [Unit]

Où Unit est le mot complet "Celsius" ou "Fahrenheit" basé sur l'entrée.

Votre méthode Error() doit retourner le format :

invalid temperature [Temp]: [Reason]

Si la température est valide, affichez la Temperature en utilisant fmt.Println (ce qui utilisera votre méthode String()). Si elle est invalide, affichez l'erreur (ce qui utilisera votre méthode Error()).

Par exemple, pour 25.5 et C, votre sortie devrait être :

25.5 degrees Celsius

Pour -500 et F, votre sortie devrait être :

invalid temperature -500: below absolute zero

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

Aide-mémoire

La bibliothèque standard de Go définit deux interfaces essentielles : fmt.Stringer et error.

L'interface Stringer

L'interface Stringer du package fmt nécessite une méthode :

type Stringer interface {
    String() string
}

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

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 years old)
}

L'interface error

L'interface error nécessite une méthode Error() qui retourne 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, ce qui 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: invalid format
}

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())
}