Comment j'ai arrêté de m'inquiéter et appris à aimer les interfaces Go

Salut, chers amis débutants en Go (ou devrais-je dire Gophers en formation ?) ! ?
Les interfaces semblaient être une de ces choses mystérieuses et magiques dont tout le monde parlait sans que personne ne l'explique vraiment d'une manière qui ait du sens. "C'est comme le polymorphisme mais en plus simple", ont-ils déclaré. « C’est comme un contrat », affirment-ils. Mais chaque fois que j'essayais d'en implémenter un, mon code me regardait comme : « Qu'est-ce que tu fais, humain ? ?

Mais c'était alors. Désormais, les interfaces et moi sommes dans de bien meilleurs termes, et je suis là pour vous aider à éviter ma confusion initiale. Donc, si vous vous grattez la tête à propos des interfaces Go, prenez une tasse de café (ou de thé) et décomposons-le, une étape à la fois, sans les maux de tête. ?
Alors, qu'est-ce qu'une interface exactement ?

Commençons par le haut. Dans Go, une interface est essentiellement un moyen de définir un comportement, mais sans s'enliser dans les détails de son fonctionnement. Imaginez que vous êtes le patron d’une usine et que vous ne vous souciez pas du fonctionnement de la machine ; vous vous souciez simplement qu'il puisse produire le produit. C'est à cela que ressemblent les interfaces Go : vous définissez ce qui doit se produire, mais pas comment cela doit être fait.

Par exemple, imaginons que nous travaillons avec des animaux (oui, Go travaille avec des animaux, reste avec moi ici). Vous savez que chaque animal fait un bruit, mais vous ne vous souciez pas vraiment de la façon dont cela se produit. Les chiens aboient, les chats miaulent et les canards… eh bien, ils cancanent. Vous pouvez définir une interface comme celle-ci :

type Animal interface {
    Sound() string
}

Qu'est-ce que c'est ça? Juste un contrat disant : "Hé, tout type qui veut être appelé Animal doit avoir une méthode Sound()." C'est ça! Aucune magie étrange impliquée.

Montrez-moi le code ! ???

Prenons un exemple très simple et voyons comment cela fonctionne en action. Nous allons créer des animaux et les faire parler.

package main

import "fmt"

// The Animal interface
type Animal interface {
    Sound() string
}

// Define a Dog
type Dog struct{}

func (d Dog) Sound() string {
    return "Woof!"
}

// Define a Cat
type Cat struct{}

func (c Cat) Sound() string {
    return "Meow!"
}

func main() {
    // Our Animal variable can hold any type that satisfies the interface
    var myPet Animal

    // myPet is now a Dog
    myPet = Dog{}
    fmt.Println(myPet.Sound())  // Outputs: Woof!

    // myPet is now a Cat
    myPet = Cat{}
    fmt.Println(myPet.Sound())  // Outputs: Meow!
}

Que se passe-t-il ici ?

1. Nous définissons une interface Animal qui a une méthode : Sound() ?.
2. Ensuite, nous créons deux types, Chien et Chat, et leur donnons leurs méthodes Sound() uniques.
3. Dans la fonction main(), nous créons une variable myPet qui peut contenir tout ce qui satisfait à l'interface Animal.
4. Tout d'abord, on attribue un chien, et boum ! Notre chien aboie : "Woof !" ?
5. Ensuite, on attribue un chat, et devinez quoi ? Il miaule : "Miaou !" ?

C'est ici que la magie des interfaces Go entre vraiment en jeu ??:
tant qu'un type a la méthode requise, il satisfait l'interface. Pas besoin de dire explicitement « Le chien met en œuvre un animal » : Go est assez intelligent pour le comprendre tout seul ! ??

Pourquoi devriez-vous vous soucier des interfaces ?

Laissez-moi vous mettre au niveau. Au début, je me disais : « Pourquoi s’embêter avec ça ? Je peux simplement écrire mes méthodes directement ! » Mais croyez-moi, vous voudrez comprendre les interfaces le plus tôt possible, surtout lorsque votre base de code commencera à croître.

Voici pourquoi :

1. Flexibilité : les interfaces rendent votre code plus flexible. Vous pouvez remplacer un type par un autre tant qu'il satisfait à l'interface. C’est comme embaucher quelqu’un en fonction de ses compétences plutôt que de son titre de poste.

2. Polymorphisme : vous pouvez traiter différents types de manière uniforme s'ils implémentent la même interface. C’est ce qui rend les interfaces si puissantes : c’est comme avoir une télécommande universelle qui fonctionne avec n’importe quel téléviseur.

3. Code propre : les interfaces vous permettent d'écrire du code plus propre et plus modulaire. Vous définissez les comportements et laissez les types gérer leur propre implémentation.

Plusieurs méthodes, pas de problème !

Passons à la vitesse supérieure. Supposons que vous construisiez un système pour travailler avec des formes et que vous souhaitiez calculer à la fois l'aire et le périmètre de différentes formes comme des cercles et des rectangles. Entrez dans l'interface multi-méthodes !

type Animal interface {
    Sound() string
}

L'interface vide (interface{})

Oh, tu pensais que nous avions fini ???? Non! Allons un peu plus loin avec l'interface vide, interface{}, qui est la manière de Go de dire : « Je peux contenir n'importe quel type ». C'est comme une boîte de chacun pour tous dans laquelle vous pouvez ajouter n'importe quoi : des chaînes, des nombres, des structures, vous l'appelez.

package main

import "fmt"

// The Animal interface
type Animal interface {
    Sound() string
}

// Define a Dog
type Dog struct{}

func (d Dog) Sound() string {
    return "Woof!"
}

// Define a Cat
type Cat struct{}

func (c Cat) Sound() string {
    return "Meow!"
}

func main() {
    // Our Animal variable can hold any type that satisfies the interface
    var myPet Animal

    // myPet is now a Dog
    myPet = Dog{}
    fmt.Println(myPet.Sound())  // Outputs: Woof!

    // myPet is now a Cat
    myPet = Cat{}
    fmt.Println(myPet.Sound())  // Outputs: Meow!
}

L'interface vide est souvent utilisée dans des situations où vous ne savez pas à l'avance à quel type vous aurez affaire (pensez aux API ou aux bibliothèques). C’est comme la version Go d’un joker.

Adoptez l'interface

L'apprentissage des interfaces Go peut donner l'impression de naviguer dans un labyrinthe au début, mais une fois que vous avez compris les bases, cela ouvre un tout nouveau monde de code flexible, réutilisable et propre. Alors n'ayez pas peur de plonger !

Commencez simple, jouez avec de petits exemples et laissez la magie de l'interface de Go grandir sur vous. D’ici peu, vous écrirez du code aussi propre et flexible qu’un professeur de yoga lors d’une conférence technique.

Bon codage, amis Gophers ! Que vos interfaces soient simples et que vos structures soient toujours mises en œuvre. ?✌️

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!