Gestion des interfaces dans Go

Les interfaces Go fournissent un mécanisme puissant d'abstraction. Cependant, leur utilisation peut poser certains défis lorsqu'il s'agit de plusieurs interfaces et types concrets.

Comprendre les interfaces Go

Contrairement aux langages comme C et Java, Go ne prend pas en charge les héritage de classe. Au lieu de cela, les interfaces servent de forme de polymorphisme qui permet à des types non liés d'implémenter le même ensemble de méthodes. Ils ne définissent aucun détail d'implémentation sous-jacent.

Interfaces multiples et implémentation

Dans votre exemple, vous rencontrez un problème lorsque vous tentez d'accéder à la représentation sous forme de chaîne ("String( )") pour une instance de votre interface "Carte". En effet, l'interface elle-même ne définit pas cette méthode.

Bonnes pratiques en matière de conception d'interface

Pour résoudre ce problème et optimiser la conception de votre interface, tenez compte des éléments suivants :

• Éviter de masquer l'implémentation : Bien que vous souhaitiez peut-être initialement masquer votre type de structure pour appliquer l'encapsulation, Go n'est pas exporté ("minuscules") Les champs struct empêchent déjà la manipulation directe des données internes.
• Renvoyer des types concrets : Dans la plupart des cas, il est préférable de renvoyer des types concrets plutôt que des interfaces. Cela simplifie le code client et maintient la clarté.

• Déclarer les interfaces prématurées (si nécessaire) : Ne déclarer les interfaces avant l'implémentation que si :

  • Implémentations multiples de l'interface existe et les clients échangent dynamiquement entre eux.
  • Les clients utilisent l'interface avec des fonctions typées statiquement ou types.
• Atténuer l'impact sur la documentation : La déclaration d'interfaces prématurées peut avoir un impact sur la clarté de la documentation. Utilisez les commentaires de la documentation pour expliquer l'objectif et les contraintes de toutes les méthodes d'interface.

Approche alternative

Au lieu d'utiliser une interface pour définir à la fois l'API "Carte" et la conversion de chaîne, pensez à utiliser l'intégration :

type Card struct {
    cardNum int
    face    string
    suit    string
}

// Interface for the Card's game-related behavior
type GameCard interface {
    GetFace() string
    GetSuit() string
}

// Embedded interface for string conversion
type Stringer interface {
    String() string
}

// Implement both interfaces on the Card type
func (c *Card) GetFace() string {
    return c.face
}

func (c *Card) GetSuit() string {
    return c.suit
}

func (c *Card) String() string {
    return fmt.Sprintf("%s%s ", c.GetFace(), c.GetSuit())
}

// Usage:
func main() {
    // Create a Card instance and access its methods
    card := Card{cardNum: 0}
    fmt.Println(card.GetFace())
    fmt.Println(card.GetSuit())
    fmt.Println(card.String())
}

Cette approche vous permet de définir des interfaces distinctes pour différentes préoccupations (logique de jeu et conversion de chaînes) et de les implémenter sur la même structure.