Interfaces en

À propos de Interfaces

L'interface en tant qu'ensemble de méthodes

Dans sa forme la plus simple, un type interface est un ensemble de signatures de méthodes. Voici un exemple de définition d'interface qui inclut deux méthodes Add et Value :

type Counter interface {
    Add(increment int)
    Value() int
}

Les noms des paramètres comme increment peuvent être omis de la définition de l'interface, mais ils améliorent souvent la lisibilité.

En Go, les noms d'interfaces ne contiennent pas le mot Interface ni I. Ils se terminent souvent par er, par exemple Reader, Stringer.

Implémente une interface

Tout type qui définit les méthodes de l'interface « implémente » automatiquement et implicitement cette interface. Il n'existe pas de mot-clé implements en Go.

Le type suivant implémente l'interface Counter que nous avons vue plus haut.

type Stats struct {
    value int
    // ...
}

func (s Stats) Add(v int) {
    s.value += v
}

func (s Stats) Value() int {
    return s.value
}

func (s Stats) SomeOtherMethod() {
    // The type can have additional methods not mentioned in the interface.
}

Pour implémenter l'interface, peu importe que la méthode ait un récepteur de valeur ou un récepteur pointeur. (Reviens sur les concepts des méthodes si tu n'es pas sûr de ce dont il s'agit.)

Une valeur de type interface peut contenir n'importe quelle valeur qui implémente ces méthodes. ¹

Cela signifie que Stats peut désormais être utilisé partout où l'interface Counter est attendue.

func SetUpAnalytics(counter Counter) {
    // ...
}

stats := Stats{}
SetUpAnalytics(stats)
// works because Stats implements Counter

Si tous les paramètres et toutes les valeurs de retour d'une fonction devaient utiliser des types concrets (c'est-à-dire non-interface), cela limiterait fortement sa réutilisabilité. En utilisant des types interface pour les paramètres, on ne définit que le comportement dont la fonction a besoin pour faire son travail. La fonction peut alors être utilisée avec des paramètres de différents types concrets, tant que ces types concrets implémentent l'interface. La même logique s'applique lorsqu'on utilise des types interface comme valeurs de retour.

Comme les interfaces sont implémentées implicitement, un type peut facilement implémenter plusieurs interfaces. Il lui suffit de définir toutes les méthodes nécessaires.

Combine des interfaces

Les définitions d'interface peuvent inclure d'autres interfaces. Voici un exemple issu de la bibliothèque standard.

type ReadCloser interface {
	Reader
	Closer
}

// Based on these interfaces:

type Reader interface {
	Read(p []byte) (n int, err error)
}

type Closer interface {
	Close() error
}

Au lieu de répéter les signatures des méthodes Read et Close pour définir ReadCloser, la définition d'interface réutilise les définitions existantes de Reader et Closer.

Interface vide

Il existe un type interface très particulier en Go : le type interface vide, qui ne contient aucune méthode. L'interface vide s'écrit comme ceci : interface{}. À partir de Go 1.18, on peut aussi utiliser any. Il a été défini comme un alias.

Comme l'interface vide n'a aucune méthode, tous les types l'implémentent implicitement. C'est utile pour définir une fonction capable d'accepter n'importe quelle valeur de façon générique. Dans ce cas, le paramètre de la fonction utilise le type interface vide.

Par exemple :

func AnythingGoes(i interface{}) string {
    if i == 0 {
        return "zero"
    }
    if i == "" {
        return "empty string"
    }
    return "something else"
}

1. Tour of Go : les interfaces ↩