Qu'est-ce que les interfaces dans le langage Go?

L'interface en Go est une collection de signatures de méthodes. Elle définit le comportement d'un objet : ce qu'il "peut faire". L'interface ne contient pas de données ni d'implémentations de méthodes.

Caractéristiques clés :

1. Implémentation implicite : Un type implémente une interface implicitement s'il fournit toutes les méthodes déclarées dans l'interface. Il n'est pas nécessaire de déclarer explicitement qu'un type implémente l'interface.
2. "Typage de canard" (Duck Typing) : "Si ça quack comme un canard et marche comme un canard, alors c'est un canard". En Go, le type de l'objet n'est pas important, mais s'il implémente l'ensemble requis de méthodes.
3. Valeur zéro : La valeur zéro d'une interface est nil. La valeur d'une interface peut être nil si à la fois le type et la valeur qu'elle contient sont nil.
4. Interface vide (interface{} ou any) : Peut contenir une valeur de n'importe quel type. Souvent utilisée pour travailler avec des données de types inconnus ou dans des conteneurs génériques.

Exemple de définition et d'utilisation :

// Définir l'interface Greeter
type Greeter interface {
	Greet() string // Méthode Greet qui retourne une chaîne
}

// Définir le type Person
type Person struct {
	Name string
}

// Person implémente l'interface Greeter en fournissant la méthode Greet
func (p Person) Greet() string {
	return "Bonjour, " + p.Name
}

// Définir le type Robot
type Robot struct {
	Model string
}

// Robot implémente également l'interface Greeter
func (r Robot) Greet() string {
	return "Salut, modèle " + r.Model
}

// La fonction prend une interface Greeter
func SayHello(g Greeter) {
	fmt.Println(g.Greet()) // Appel de la méthode Greet via l'interface
}

func main() {
	person := Person{Name: "Alicia"}
	robot := Robot{Model: "RX-800"}

	SayHello(person) // Passe un Person qui implémente Greeter
	SayHello(robot)  // Passe un Robot qui implémente Greeter
}

Les interfaces favorisent une conception flexible et découplée, permettant d'écrire des fonctions qui fonctionnent avec différents types de données, tant que ces types implémentent l'interface requise. Elles sont utilisées pour créer du code générique et dans la bibliothèque standard de Go (par exemple, io.Reader, io.Writer, fmt.Stringer).