Go et héritage : quand la composition surpasse-t-elle l'héritage pour la réutilisabilité du code ?

Go et l'héritage : adopter la composition pour la réutilisabilité du code

Dans Go, l'extension des fonctionnalités au-delà des structures de base est souvent abordée en utilisant la composition au lieu de l'héritage. Cela garantit la clarté du code et minimise la duplication.

Considérez l'exemple suivant où l'objectif est de définir une structure de base avec des méthodes qui peuvent être étendues par d'autres structures :

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
}

Pendant que cet exemple fonctionne , il semble alambiqué en raison de sa structure cyclique. Pour réduire la duplication de code et créer un code plus lisible, envisagez d'utiliser l'intégration.

L'intégration vous permet de composer des structures qui implémentent des interfaces spécifiques. Par exemple, vous pouvez créer des interfaces étroites pour la lecture et l'écriture :

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

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

En composant ces interfaces, vous pouvez créer une interface ReadWriter :

type ReadWriter interface {
    Reader
    Writer
}

De même, vous pouvez composer des structures qui implémentez Reader et Writer dans une structure MyReadWriter :

type MyReader struct {}
func (r *MyReader) Read(p []byte) (n int, err error) {
    // Implements Reader interface.
}
type MyWriter struct {}
func (w *MyWriter) Write(p []byte) (n int, err error) {
    // Implements Writer interface.
}

type MyReadWriter struct {
    *MyReader
    *MyWriter
}

La structure MyReadWriter implémente désormais l'interface ReadWriter, vous permettant d'utiliser n'importe quel composant qui implémente Reader ou Writer dans cette structure.

Cette intégration Cette technique favorise la réutilisabilité du code, l'injection de dépendances et facilite les tests en permettant l'échange de composants qui implémentent des interfaces spécifiques.

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!