Comment puis-je déterminer si une structure Go avec une interface intégrée a une « véritable » implémentation de fonction à l'aide de Reflection ?

Go Reflection avec l'interface intégrée dans Struct : détermination des fonctions "réelles"

Dans le contexte du package de réflexion de Go, comprendre le comportement de struct les champs intégrés avec des interfaces anonymes sont cruciaux. Considérez l'extrait de code suivant :

type A interface {
    Foo() string
}

type B struct {
    A
    bar string
}

Bien qu'il soit intuitif de supposer que B doit implémenter l'interface A, la nature dynamique de Go permet une interprétation différente. La valeur d'interface anonyme intégrée dans B sert de champ, similaire aux autres champs de structure.

En utilisant la réflexion, vous pouvez récupérer des méthodes du type de B comme suit :

bType := reflect.TypeOf(B{})
bMeth, has := bType.MethodByName("Foo")

Cependant, la présence de bMeth ne garantit pas l'existence d'une "vraie" implémentation de fonction pour B. Pour éviter des paniques comme celle que vous avez rencontrée, vous avez besoin d'un moyen de déterminer s'il existe une fonction réelle définie pour B.

Détection de l'absence d'une implémentation

La clé pour différencier une fonction "réelle" d'une méthode d'interface héritée réside dans l'aspect interface de l'anonyme intégré interface. Lorsqu'aucune implémentation explicite n'existe dans la structure, la méthode d'interface est effectivement héritée de l'interface intégrée.

Pour vérifier la présence d'une fonction réelle :

if bMeth.Type.NumIn() == 1 && bMeth.Type.NumOut() == 1 {
    fmt.Println("Real function found")
} else {
    fmt.Println("Interface method inherited")
}

Cette vérification examine le nombre des paramètres d’entrée et de sortie pour la méthode récupérée. S'ils valent tous les deux 1, cela indique que la méthode est une "vraie" implémentation de fonction, car elle accepte un paramètre du récepteur (l'instance B) et renvoie une valeur. Sinon, si ces nombres diffèrent, la méthode est héritée de l'interface.

Approche alternative : changement de type

Au lieu d'utiliser la réflexion, vous pouvez utiliser le changement de type pour sélectionner sélectivement exécuter en fonction du type dynamique de b.A. Si b.A est nul, cela indique l'absence d'une implémentation « réelle ».

switch b.A.(type) {
case nil:
    fmt.Println("No function implementation in B")
default:
    fmt.Println("Function implementation found")
}

Conclusion

En comprenant la nature des interfaces anonymes embarquées et en employant l'une ou l'autre réflexion avec des vérifications personnalisées ou un changement de type, vous pouvez déterminer efficacement la présence de fonctions « réelles » pour les champs de structure qui héritent des méthodes d'interface.

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!