Comment puis-je réutiliser du code lors de l'implémentation d'une méthode commune pour différents types dans Go ?

Implémentation de méthodes communes avec des interfaces dans Go

Dans Go, les interfaces fournissent un mécanisme permettant à différents types d'implémenter le même ensemble de méthodes, permettant pour le polymorphisme dans votre code. Cependant, vous pouvez parfois rencontrer une situation dans laquelle vous souhaitez que deux types distincts implémentent une méthode commune tout en évitant le code redondant.

Considérez le scénario suivant :

type First struct {
    str string
}

type Second struct {
    str string
}

type A interface {
    PrintStr()
}

Pour implémenter la méthode PrintStr pour à la fois les structures First et Second, vous écrivez généralement les méthodes distinctes suivantes :

func (f First) PrintStr() {
    fmt.Print(f.str)
}

func (s Second) PrintStr() {
    fmt.Print(s.str)
}

Bien que cette approche soit fonctionnelle, elle peut conduire à une duplication de code si vous ont plusieurs types qui doivent implémenter la même méthode. Pour surmonter ce problème, Go propose une solution élégante connue sous le nom d'incorporation de types.

Incorporation de types

L'incorporation de types vous permet de composer de nouveaux types en y incorporant des types existants. Dans ce cas, nous pouvons créer un type de base qui contient le champ str commun et la méthode PrintStr.

type WithString struct {
    str string
}

func (w WithString) PrintStr() {
    fmt.Print(w.str)
}

Maintenant, nous pouvons intégrer le type WithString dans nos première et deuxième structures :

type First struct {
    WithString
}

type Second struct {
    WithString
}

Ce faisant, les structures First et Second héritent de la méthode PrintStr du type WithString intégré. Cela élimine le besoin d'implémentations de méthodes distinctes pour chaque structure.

Exemple

Voici un exemple de la façon d'utiliser l'intégration de types pour implémenter une méthode commune pour deux types différents :

package main

import "fmt"

type WithString struct {
    str string
}

func (w WithString) PrintStr() {
    fmt.Print(w.str)
}

type First struct {
    WithString
}

type Second struct {
    WithString
}

func main() {
    a := First{
        WithString: WithString{
            str: "foo",
        },
    }

    a.PrintStr() // Outputs: foo
}

Cette approche vous permet de conserver une seule implémentation pour la méthode commune tout en permettant son utilisation par différents types, favorisant ainsi le code réutilisabilité et réduction de la duplication de code.

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!