Go Academy · Leçon

Intégration d’interfaces

Composer des interfaces

Intégration d’interfaces 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.

Composer des interfaces

Les interfaces peuvent intégrer d’autres interfaces et combiner leurs ensembles de méthodes en un contrat plus vaste. La bibliothèque standard utilise cette technique partout.

Syntaxe d’intégration

Répertoriez un type d’interface dans une autre interface pour inclure toutes ses méthodes.

package main

import "fmt"

type Reader interface{ Read() string }
type Writer interface{ Write(s string) }
type ReadWriter interface {
	Reader
	Writer
}

func main() {
	var rw ReadWriter
	fmt.Println(rw == nil)
}

io.ReadWriter en pratique

L’exemple classique est io.ReadWriter, défini par l’intégration de io.Reader et io.Writer. Tout type possédant ces deux méthodes le satisfait.

Satisfaire une interface composée

Un type concret implémente simplement l’interface combinée en possédant toutes les méthodes requises.

package main

import "fmt"

type Reader interface{ Read() string }
type Writer interface{ Write(s string) }
type ReadWriter interface {
	Reader
	Writer
}

type File struct{ data string }

func (f *File) Read() string  { return f.data }
func (f *File) Write(s string) { f.data = s }

func main() {
	var rw ReadWriter = &File{}
	rw.Write("hi")
	fmt.Println(rw.Read())
}

Pourquoi composer des interfaces

Les petites interfaces sont faciles à implémenter et à vérifier. Les composer permet de créer des contrats plus vastes uniquement lorsque cela est nécessaire, tout en gardant chaque élément minimal.

Construire à partir de petits éléments

Définissez des interfaces ciblées à méthode unique, puis combinez-les.

package main

import "fmt"

type Opener interface{ Open() }
type Closer interface{ Close() }
type OpenCloser interface {
	Opener
	Closer
}

type Door struct{}

func (Door) Open()  { fmt.Println("opened") }
func (Door) Close() { fmt.Println("closed") }

func main() {
	var oc OpenCloser = Door{}
	oc.Open()
	oc.Close()
}

Aucune méthode en double

Les interfaces intégrées ne doivent pas fournir de méthodes qui se chevauchent avec des signatures incompatibles ; des ensembles de méthodes identiques sont acceptés dans les versions modernes de Go.

Accepter des interfaces étroites

Les fonctions doivent demander l’interface la plus petite dont elles ont besoin. Acceptez io.Reader, et non io.ReadWriteCloser, si vous ne faites que lire.

package main

import "fmt"

type Reader interface{ Read() string }

func dump(r Reader) { fmt.Println(r.Read()) }

type Buf struct{}

func (Buf) Read() string { return "data" }

func main() {
	dump(Buf{})
}

La famille io

La bibliothèque standard compose Reader, Writer et Closer en ReadCloser, WriteCloser et ReadWriteCloser — un ensemble cohérent de contrats.

Interfaces composées dans les interfaces de programmation

Renvoyez l’interface la plus large prise en charge par une valeur, mais acceptez l’interface la plus étroite utilisée par votre fonction. Vous maximisez ainsi à la fois la flexibilité et la clarté.

Intégration d’interfaces ou de structures

L’intégration de structures promeut les champs et les méthodes pour réutiliser un comportement
L’intégration d’interfaces combine les exigences de méthodes en un contrat plus vaste

Vérification rapide

Vérifiez vos connaissances sur l’intégration d’interfaces.

Récapitulatif

Vous avez découvert l’intégration d’interfaces.

Répertoriez des interfaces dans une autre pour fusionner leurs ensembles de méthodes
Le paquetage io compose les interfaces de lecture, d’écriture et de fermeture
Gardez les interfaces de base petites ; composez-les lorsque cela est nécessaire
Acceptez l’interface la plus étroite requise par une fonction

Questions Fréquemment Posées

La leçon « Intégration d’interfaces » est-elle gratuite ?

Oui — le texte complet de « Intégration d’interfaces » 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 « Intégration d’interfaces » ?

Composer des interfaces 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 « Intégration d’interfaces » ?

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

← Retour à Go Academy