Comment puis-je obtenir une extensibilité de type héritage dans Go sans utiliser l'héritage traditionnel ?

Golang et héritage : approches alternatives de l'extensibilité

Aperçu du problème :

Objectif : créer une structure de base avec des éléments réutilisables méthodes qui peuvent être étendues par d’autres structures. Cependant, la structure de Go restreint l'accès aux méthodes de la structure parent, rendant l'héritage traditionnel impossible.

Modèle original :

L'utilisateur propose un modèle alambiqué impliquant un comportement de type héritage. :

type MyInterface interface {
  SomeMethod(string)
  OtherMethod(string)
}

type Base struct{
  B MyInterface
}

func (b *Base) SomeMethod(x string) {
  b.B.OtherMethod(x)
}

type Extender struct {
  Base
}

func (b *Extender) OtherMethod(x string) {
  // Do something...
}

func NewExtender() *Extender { 
  e := Extender{}
  e.Base.B = &e
  return &e
}

Approche de Go : la composition plutôt que l'héritage

Go encourage la composition plutôt que l'héritage pour plus de flexibilité et de maintenabilité. Au lieu de sous-classer, Go favorise l'utilisation d'interfaces et l'intégration de structures pour obtenir l'extensibilité.

Intégration :

L'intégration permet à une structure d'inclure directement les champs et les méthodes d'une autre structure, réutilisant ainsi efficacement sa fonctionnalité. Par exemple, si nous avons une interface Reader et Writer, nous pouvons créer une interface ReadWriter combinée et intégrer les implémentations Reader et Writer :

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

type Writer interface {
    Write(p []byte) (n int, err error)
}

type ReadWriter interface {
    Reader
    Writer
}

type MyReadWriter struct {
    *MyReader
    *MyWriter

    // Additional ReadWriter-specific methods if needed
}

La structure MyReadWriter peut désormais accéder et utiliser toutes les méthodes de MyReader et MyWriter, implémentant l'interface ReadWriter de manière transparente.

Injection de dépendances :

L'intégration facilite également l'injection de dépendances, ce qui permet de meilleurs tests et découplages. MyReader et MyWriter peuvent être injectés dans la structure MyReadWriter, garantissant que les dépendances sont transmises explicitement, améliorant ainsi la testabilité.

Exemple d'utilisation :

func (rw *MyReadWriter) DoCrazyStuff() {
    data := []byte{}
    // Do stuff...
    rw.Read(data)
    rw.Write(data)
    // You get the idea...
}

func main() {
    rw := &MyReadWriter{&MyReader{}, &MyWriter{}}
    rw.DoCrazyStuff()
}

Dans ce Par exemple, la structure rw peut agir à la fois comme lecteur et comme écrivain, permettant une utilisation polyvalente dans divers scénarios.

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!