Comment gérer les champs partagés dans différentes structures avec des génériques dans Go ?

Gestion des champs partagés dans différentes structures avec des génériques

Lorsque vous travaillez avec des packages externes, il peut être difficile de définir des fonctions génériques qui opèrent sur des structures contenant des membres communs. Cet article explore un problème dans lequel une tentative a été faite pour créer une fonction générique pour modifier les champs partagés de deux structures de message Firebase distinctes, Message et MulticastMessage.

Malgré avoir Avec des champs de configuration Android similaires, ces structures n'ont aucune relation explicite et les tentatives d'accès à leurs propriétés communes directement à l'aide de paramètres de type entraînaient des erreurs. La raison en est que Go 1.18 ne prend pas encore en charge l'accès aux champs communs ou aux méthodes de paramètres de type, comme expliqué dans les fils de discussion liés.

Options de solution

Pour résoudre ce problème, plusieurs solutions sont proposées. proposé :

1. Type Switch

Si le nombre de types impliqués est limité, une instruction type switch peut être utilisée pour accéder aux champs partagés :

<code class="go">func highPriority[T firebaseMessage](message T) T {
    switch m := any(message).(type) {
    case *messaging.Message:
        setConfig(m.Android)
    case *messaging.MulticastMessage:
        setConfig(m.Android)
    }
    return message
}</code>

2. Wrapper avec méthode

Cette méthode implique de créer une structure wrapper avec la méthode supplémentaire que vous souhaitez utiliser dans la fonction générique :

<code class="go">type MessageWrapper struct {
    messaging.Message
}

func (w *MessageWrapper) SetConfig(cfg messaging.Android) {
    *w.Android = cfg
}</code>

La fonction générique peut alors accéder à cette méthode commune :

<code class="go">func highPriority[T wrappedMessage](message T) T {
    message.SetConfig(messaging.Android{"some-value"})
    return message
}</code>

3. Réflexion

Si le nombre de structures est important, la réflexion peut être utilisée pour accéder dynamiquement aux champs partagés :

<code class="go">func highPriority[T firebaseMessage](message T) T {
    cfg := &messaging.Android{}
    reflect.ValueOf(message).Elem().FieldByName("Android").Set(reflect.ValueOf(cfg))
    return message
}</code>

Notes

Il est important de noter que ces solutions ont leurs limites :

• Les méthodes de commutation de type et de wrapper sont moins adaptées à un grand nombre de types.
• La réflexion nécessite des structures et des champs adressables.

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!