Comment puis-je gérer les types génériques pour les pointeurs implémentant des interfaces dans Go ?

Types génériques pour les pointeurs implémentant des interfaces dans Go

Dans Go, lorsque vous travaillez avec des interfaces, il peut être utile de créer des fonctions génériques qui fonctionnent sur les types de données qui implémentent ces interfaces. Cependant, si l'interface représente un type de pointeur, déterminer le type générique du pointeur peut s'avérer difficile.

Pour résoudre ce problème, Go fournit un mécanisme pour déclarer les interfaces avec des paramètres de type, ce qui permet de définir des interfaces qui attendent le type d’implémentation doit être un pointeur vers son paramètre de type. Par exemple, considérons l'interface suivante :

type A interface {
  SomeMethod()
}

Si vous avez une implémentation de cette interface via un pointeur de structure, telle que :

type Aimpl struct {}

func (a *Aimpl) SomeMethod() {}

Vous pouvez rencontrer des problèmes lorsque vous tentez de transmettre un pointeur vers Aimpl vers une fonction générique qui attend une fonction avec un paramètre A. La raison en est que la fonction générique attend un type qui implémente l'interface A, et non un pointeur vers un type qui l'implémente.

Pour résoudre ce problème, vous pouvez modifier la définition de l'interface pour spécifier un paramètre de type. :

type A[P any] interface {
  SomeMethod()
  *P
}

Cela indique que l'interface attend qu'un type l'implémentant soit un pointeur vers le paramètre de type P.

Ensuite, vous devez ajuster la signature de la fonction générique pour accepter le type d'interface modifié :

func Handler[P any, T A[P]](callback func(result T)) {
  result := new(P)
  callback(result)
}

La fonction générique prend désormais une fonction avec un paramètre de type T, qui doit implémenter l'interface A modifiée. Lorsque vous invoquez la fonction avec un pointeur vers Aimpl, elle identifiera correctement le type d'implémentation et s'exécutera comme prévu.

Cependant, si vous ne parvenez pas à modifier la définition de l'interface A d'origine, vous pouvez créer la vôtre. interface wrapper qui inclut le paramètre type :

type MyA[P any] interface {
  A
  *P
}

En encapsulant l'interface d'origine, vous pouvez utiliser la même approche qu'avant :

func Handler[P any, T MyA[P]](callback func(result T)) {
  result := new(P)
  callback(result)
}

Cela permet vous devez travailler avec des types de pointeurs qui implémentent l'interface A d'origine tout en conservant le comportement générique souhaité.

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!