Comment définir et utiliser des interfaces à Golang?

Une interface dans GO est un type qui définit un ensemble de signatures de méthode, et tout type implémentant ces méthodes satisfait automatiquement l'interface sans déclaration explicite. 1. Définissez une interface avec des signatures de méthode, comme le haut-parleur avec la chaîne Speak (). 2. Implémentez l'interface en fournissant les méthodes sur n'importe quel type, telles que les structures de chien et de chat avec une méthode Speak (). 3. Utilisez des valeurs d'interface de manière interchangeable, comme indiqué avec une tranche de haut-parleur tenant à la fois le chien et le chat. 4. Utilisez n'importe quelle (ou interface {}) pour accepter tout type, mais appliquez des assertions de type ou des commutateurs de type pour récupérer le type sous-jacent en cas de besoin. 5. Suivez les meilleures pratiques: Gardez les interfaces petites, laissez-les émerger naturellement, utilisez n'importe quel avec parcimonie, préfèrent les récepteurs de valeur et tirez parti des modèles de bibliothèque standard comme io.writer. Les interfaces dans GO favorisent le polymorphisme, la flexibilité et la conception propre en se concentrant sur le comportement plutôt que sur la mise en œuvre, en rendant le code composable, réutilisable et testable.

Dans GO, les interfaces sont un moyen puissant d'atteindre le polymorphisme et le code de découple. Ils vous permettent de définir le comportement sans spécifier l'implémentation, ce qui rend votre code plus flexible et réutilisable.

Qu'est-ce qu'une interface dans Go?

Une interface est un type qui spécifie un ensemble de signatures de méthode. Tout type qui implémente toutes les méthodes de l'interface le satisfait automatiquement - il n'est pas nécessaire de le déclarer explicitement. Ceci est connu sous le nom d'implémentation implicite .

Voici comment vous définissez une interface de base:

 Tapez l'interface du haut-parleur {
    String Speak ()
}

Cette interface Speaker nécessite que tout type d'implémentation ait une méthode Speak() qui renvoie une chaîne.

Comment implémenter une interface

Tout type (comme une structure) peut implémenter l'interface en fournissant les méthodes requises.

 Type Dog Struct {
    Chaîne de noms
}

func (d chien) dispens () String {
    retourne "woof! je suis".
}

Type Cat Struct {
    Chaîne de noms
}

func (c cat) disppe () string {
    Retour "Meow! I'm" C.Name
}

Désormais, Dog et Cat satisfont l'interface Speaker car ils ont une méthode Speak() string .

Vous pouvez les utiliser de manière interchangeable:

 func main () {
    Animaux: = [] Président {chien {nom: "Buddy"}, chat {nom: "Whiskers"}}

    pour _, animal: = gamme animaux {
        fmt.println (animal.speak ())
    }
}

Sortir:

 Trame! Je suis mon pote
Miaou! Je suis des moustaches

Remarque: L'attribution à Speaker fonctionne car GO vérifie au moment de la compilation si les types implémentent les méthodes requises.

Interface vide: interface{} (pre-go 1.18)

Avant GO 1.18, l'interface vide a été écrite sous forme interface{} et pourrait conserver n'importe quelle valeur car elle n'a pas de méthodes:

 var x interface {} = "Bonjour"
interface var y {} = 42

À partir de Go 1.18, vous pouvez any utiliser comme un alias plus lisible:

 var x any = "bonjour"

Les deux interface{} et any qui signifie la même chose.

Utile pour les fonctions qui acceptent tout type:

 func print (v any) {
    fmt.println (v)
}

Mais n'oubliez pas: vous aurez probablement besoin de types de type assertions ou de commutateurs de type pour récupérer la valeur sous-jacente.

Tapez des assertions et des commutateurs de type

Étant donné que les interfaces masquent les types de béton, vous devrez peut-être extraire le type d'origine.

Affirmation de type :

 Si chien, ok: = animal. (chien); d'accord {
    fmt.println ("a trouvé un chien:", dog.name)
}

Interrupteur de type :

 commutateur v: = animal. (type) {
Chien de cas:
    fmt.println ("c'est un chien:", v.name)
Case Cat:
    fmt.println ("c'est un chat:", v.name)
défaut:
    fmt.println ("animal inconnu")
}

Cela est particulièrement utile lors de la gestion des différents comportements en fonction du type réel.

Meilleures pratiques et conseils

• Gardez les interfaces petites : Go Favors petites interfaces focalisées (comme io.Reader , io.Writer ).
• Laissez les interfaces émerger naturellement : ne forcez pas les types à satisfaire les grandes interfaces. Définissez les interfaces si nécessaire, et non à l'avance.
• Utilisez l'interface {} (ou tout) avec parcimonie : il perd la sécurité de type. Les génériques (introduits dans GO 1.18) sont souvent un meilleur choix.
• Préférez les récepteurs de valeur sauf si la mutation est nécessaire : les types de récepteurs cohérents aident à éviter les décalages accidentels d'interface.

Exemple: utilisant des interfaces de style bibliothèque standard

La bibliothèque standard de GO utilise fortement ce modèle. Par exemple:

 Type d'interface d'écrivain {
    Écrire ([] octet) (n int, err error)
}

Vous pouvez écrire une fonction qui fonctionne avec n'importe quel écrivain:

 func saluer (w io.writer, nom de nom) {
    fmt.fprintf (w, "bonjour,% s! \ n", nom)
}

Maintenant, cela fonctionne avec les fichiers, les connexions réseau, les tampons, etc., tant qu'ils implémentent Write .

Fondamentalement, les interfaces dans GO concernent ce qu'un type peut faire , pas ce qu'il est. Vous les définissez par le comportement dont ils ont besoin et les types les satisfont automatiquement en mettant en œuvre les méthodes. Il garde les choses simples, composables et testables.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!