Comment fonctionnent les interfaces en Go ?

Question

Accepted Answer

Une **interface** Go définit un ensemble de signatures de méthodes — un contrat de comportement. Crucialmente, les interfaces sont satisfaites **implicitement** : tout type qui possède ces méthodes satisfait automatiquement l'interface, **sans déclaration explicite « implements »**. Cette approche structurelle de duck-typing est distinctive et puissante.

## Définir et implémenter implicitement une interface

```go
// define an interface — a set of method signatures
type Speaker interface {
    Speak() string
}

type Dog struct{}
func (d Dog) Speak() string { return "Woof" }   // Dog has Speak() → it IS a Speaker

type Cat struct{}
func (c Cat) Speak() string { return "Meow" }   // Cat too — implicitly

// NO "implements Speaker" anywhere — satisfaction is automatic
var s Speaker = Dog{}    // works because Dog has the Speak() method
s.Speak()                // "Woof"
```

Il n'y a pas de mot-clé `implements` — si un type possède toutes les méthodes de l'interface, il satisfait l'interface automatiquement. Cela découple l'interface de ses implémentations (l'implémenteur n'a même pas besoin de connaître l'existence de l'interface).

## Polymorphisme via les interfaces

```go
func announce(s Speaker) {        // accepts ANY type that has Speak()
    fmt.Println(s.Speak())
}
announce(Dog{})    // "Woof"
announce(Cat{})    // "Meow"

speakers := []Speaker{Dog{}, Cat{}}   // a slice of different types via the interface
for _, sp := range speakers { sp.Speak() }
```

Les interfaces permettent le polymorphisme — écrire du code contre le comportement, et tout type conforme fonctionne.

## L'interface vide et `any`

```go
var x interface{}     // the empty interface — satisfied by EVERY type (no methods required)
x = 42
x = "hello"
// Go 1.18+: `any` is an alias for interface{}
func print(v any) { fmt.Println(v) }   // accepts anything
```

L'interface vide (`interface{}` / `any`) contient n'importe quelle valeur — utilisée quand le type n'est pas connu à l'avance (bien que les generics remplacent souvent cela maintenant).

## Les interfaces de la bibliothèque standard que vous utiliserez constamment

```go
type Stringer interface { String() string }   // controls fmt printing
type error interface { Error() string }        // the error type itself!
type io.Reader interface { Read(p []byte) (n int, err error) }
type io.Writer interface { Write(p []byte) (n int, err error) }
```

Une grande partie de la bibliothèque standard est construite sur de petites interfaces (`io.Reader`/`io.Writer`, `error`, `Stringer`) — les implémenter rend vos types compatibles avec tout l'écosystème.

## L'idiome : accepter des interfaces, retourner des structs

```text
Go favors SMALL interfaces (often one method) defined where they're USED (the consumer),
not where types are defined. "The bigger the interface, the weaker the abstraction."
```

## Pourquoi c'est important

Les interfaces sont au cœur de la conception de Go et de son approche de l'abstraction et du polymorphisme — et leur **satisfaction implicite** (pas de mot-clé `implements` ; typage structurel) est l'une des caractéristiques les plus distinctives et puissantes du langage.

Ce découplage signifie que les types et les interfaces évoluent indépendamment, vous pouvez définir des interfaces *après* les types qui les satisfont, et tout type conforme se connecte automatiquement au code basé sur les interfaces — permettant des designs flexibles et faiblement couplés, et des tests faciles (remplacer par des implémentations mock).

Comprendre l'implémentation implicite, le polymorphisme via les interfaces, l'interface vide/`any`, l'idiome des petites interfaces (« accepter des interfaces, retourner des structs »), et les interfaces ubiquitaires de la bibliothèque standard (`error`, `io.Reader`/`Writer`, `Stringer`) est essentiel pour un Go idiomatique.

C'est un sujet fréquent d'entretien précisément parce que le modèle implicite et structurel diffère fondamentalement des interfaces explicites de Java/C#.

Définir et implémenter implicitement une interface

Polymorphisme via les interfaces

L'interface vide et any

Les interfaces de la bibliothèque standard que vous utiliserez constamment

L'idiome : accepter des interfaces, retourner des structs

Pourquoi c'est important

L'interface vide et `any`