Go Academy · Leçon

Interfaces essentielles de la bibliothèque standard

fmt.Stringer, io.Reader, io.Writer

Interfaces essentielles de la bibliothèque standard est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Go Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Go Academy comprend 4 leçons au total.

fmt.Stringer

fmt.Stringer possède une méthode : String() string. Implémentez-la pour contrôler la manière dont votre type apparaît avec fmt.Println et %v :

package main
import "fmt"

type Color int
const (Red Color = iota; Green; Blue)
func (c Color) String() string {
    return []string{"Red","Green","Blue"}[c]
}

func main() {
    fmt.Println(Red, Green, Blue) // Red Green Blue
}

Interface error

L'interface intégrée error possède une méthode : Error() string. Tout type qui l'implémente peut être utilisé comme erreur :

package main
import "fmt"

type ValidationError struct{ Field, Msg string }
func (e *ValidationError) Error() string {
    return e.Field + ": " + e.Msg
}

func validate(age int) error {
    if age < 0 { return &ValidationError{"age", "must be non-negative"} }
    return nil
}

func main() {
    fmt.Println(validate(-1))
}

io.Reader

io.Reader possède une méthode : Read(p []byte) (n int, err error). Les fichiers, les corps HTTP, les chaînes et les tampons l'implémentent tous :

package main
import ("fmt"; "strings")

func countBytes(r interface{ Read([]byte)(int,error) }) int {
    buf := make([]byte, 512)
    total := 0
    for {
        n, err := r.Read(buf)
        total += n
        if err != nil { break }
    }
    return total
}

func main() {
    r := strings.NewReader("hello world")
    fmt.Println(countBytes(r)) // 11
}

io.Writer

io.Writer possède une méthode : Write(p []byte) (n int, err error). Il est utilisé par fmt.Fprintf, la journalisation, les rédacteurs de réponses HTTP, etc. :

package main
import ("bytes"; "fmt")

func main() {
    var buf bytes.Buffer
    fmt.Fprintf(&buf, "Hello, %s!", "Go")
    fmt.Println(buf.String()) // Hello, Go!
}

io.ReadWriter et io.Closer

La bibliothèque standard compose de petites interfaces pour en créer de plus grandes :

package main
import "io"

// io.ReadWriter = io.Reader + io.Writer
// io.ReadCloser = io.Reader + io.Closer
// io.ReadWriteCloser = all three

func process(rw io.ReadWriter) {
    buf := make([]byte, 8)
    rw.Read(buf)
    rw.Write(buf)
}

func main() { _ = process }

sort.Interface

sort.Interface nécessite Len() int, Less(i, j int) bool et Swap(i, j int) :

package main
import ("fmt"; "sort")

type ByLength []string
func (b ByLength) Len() int           { return len(b) }
func (b ByLength) Less(i, j int) bool { return len(b[i]) < len(b[j]) }
func (b ByLength) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }

func main() {
    fruits := ByLength{"banana","apple","kiwi"}
    sort.Sort(fruits)
    fmt.Println([]string(fruits)) // [kiwi apple banana]
}

http.Handler

http.Handler possède une méthode : ServeHTTP(ResponseWriter, *Request). Toute la pile HTTP de Go repose sur cette interface unique :

package main
import ("fmt"; "net/http")

type Hello struct{}
func (h Hello) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "Hello, World!")
}

func main() {
    http.ListenAndServe(":8080", Hello{})
}

fmt.GoStringer

Implémentez GoString() string pour contrôler la représentation %#v (syntaxe Go) de votre type :

package main
import "fmt"

type Version struct{ Major, Minor int }
func (v Version) GoString() string {
    return fmt.Sprintf("Version{%d, %d}", v.Major, v.Minor)
}

func main() {
    fmt.Printf("%#v\n", Version{1, 18}) // Version{1, 18}
}

encoding.TextMarshaler

Implémentez MarshalText() ([]byte, error) et UnmarshalText([]byte) error pour utiliser un encodage texte personnalisé (chaînes JSON, YAML, etc.) :

package main
import "fmt"

type Status int
const (Active Status = iota; Inactive)
func (s Status) MarshalText() ([]byte, error) {
    if s == Active { return []byte("active"), nil }
    return []byte("inactive"), nil
}

func main() {
    s := Active
    b, _ := s.MarshalText()
    fmt.Println(string(b)) // active
}

Composer des interfaces standard

Combinez des interfaces standard avec io.TeeReader, io.MultiWriter, etc. afin de créer de puissantes chaînes de traitement sans écrire de nouveaux types :

package main
import ("bytes"; "fmt"; "io"; "strings")

func main() {
    r := strings.NewReader("hello")
    var buf bytes.Buffer
    tee := io.TeeReader(r, &buf)
    io.ReadAll(tee)
    fmt.Println(buf.String()) // hello
}

Vérification rapide

Quelle interface un type doit-il implémenter pour pouvoir être utilisé comme erreur en Go ?

Récapitulatif

Principales interfaces de la bibliothèque standard :

fmt.Stringer : représentation personnalisée à l'affichage
error : valeurs d'erreur
io.Reader / io.Writer : entrées-sorties en flux
sort.Interface : tri personnalisé
http.Handler : gestion des requêtes HTTP

Exercice pratique

Implémentez sort.Interface sur une tranche []Person (où Person possède les champs Name et Age) pour effectuer un tri décroissant par âge. Affichez la liste triée.

Questions Fréquemment Posées

La leçon « Interfaces essentielles de la bibliothèque standard » est-elle gratuite ?

Oui — le texte complet de « Interfaces essentielles de la bibliothèque standard » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Go Academy, passe à CoddyKit PRO. Le cours Go Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Interfaces essentielles de la bibliothèque standard » ?

fmt.Stringer, io.Reader, io.Writer Tu pratiques Go Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Go Academy ?

Aucune expérience préalable n'est requise. Go Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Interfaces essentielles de la bibliothèque standard » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Go Academy ?

Oui. Chaque leçon Go Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Définir et implémenter des interfaces
Interfaces essentielles de la bibliothèque standard
Assertions de type et switch de type
Composition d’interfaces et bonnes pratiques

← Retour à Go Academy