Comment gérer l'implémentation d'interfaces avec des signatures identiques dans différents packages dans Go ?

Implémentation de deux interfaces avec des signatures identiques dans différents packages

Dans Go, les interfaces fournissent un moyen de définir un contrat pour les types qui les implémentent, garantir que tout type implémentant une interface donnée doit fournir des implémentations pour toutes ses méthodes. Cependant, l'implémentation d'interfaces avec des signatures de méthode identiques dans différents packages peut entraîner de la confusion et des incohérences.

Considérez le scénario suivant :

<code class="go">// Package A
package A

type Doer interface {
    Do() string
}

func FuncA(doer Doer) {
    // Logic using doer.Do()
}

// Package B
package B

type Doer interface {
    Do() string
}

func FuncB(doer Doer) {
    // Logic using doer.Do()
}</code>

Maintenant, supposons que vous ayez un type C dans votre package principal qui implémente à la fois A.Doer et B.Doer avec différentes implémentations pour Do(). Lors du passage d'une instance de C à FuncA(), elle se comporte comme prévu, en utilisant l'implémentation définie dans A.Doer. Cependant, lors du passage de C à FuncB(), la logique déclenche un comportement inattendu en raison de l'implémentation différente de Do().

Pour résoudre ce problème, deux approches sont recommandées :

Assertions de types de méthodes :

Selon la FAQ Go, "la correspondance uniquement par nom et l'exigence de cohérence dans les types étaient une décision de simplification majeure dans le système de types de Go." Par conséquent, Go ne prend pas en charge les méthodes de surcharge basées sur des signatures différentes. Cependant, vous pouvez effectuer des assertions de type de méthode pour vérifier si un objet satisfait à un type d'interface spécifique. Par exemple :

<code class="go">if _, ok := obj.(A.Doer); ok {
    // obj conforms to A.Doer
    // Use obj.Do() as desired
}</code>

Types de wrapper :

Alternativement, vous pouvez créer des types de wrapper autour de votre objet qui implémentent les interfaces nécessaires avec la logique souhaitée. Par exemple, vous pourriez avoir DoerA qui encapsule C et fournit une implémentation spécifique de A.Do(), et un DoerB qui encapsule C et fournit une implémentation de B.Do(). Cette approche vous permet de transmettre le type de wrapper approprié à la fonction souhaitée, garantissant ainsi l'exécution de la logique correcte.

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!