Quels paramètres ont les fonctions du décorateur Golang ?

l'éditeur php Baicao vous présentera les paramètres de la fonction décorateur Golang. Dans Golang, une fonction de décorateur est une fonction spéciale qui peut être utilisée pour envelopper d'autres fonctions et leur ajouter des fonctionnalités supplémentaires. Les fonctions de décorateur ont généralement trois paramètres : la fonction d'origine, les paramètres de la fonction de décorateur et la valeur de retour. La fonction d'origine est la fonction qui doit être décorée. Les paramètres de la fonction décorateur peuvent être de n'importe quel type et peuvent être utilisés pour transmettre des paramètres supplémentaires à la fonction décorateur. La valeur de retour est généralement une fonction qui remplace l'exécution de l'original. fonction. Grâce à ces paramètres, nous pouvons implémenter divers modes de décorateur flexibles, ajouter différentes fonctions aux fonctions et améliorer la réutilisabilité et l'évolutivité du code.

Contenu de la question

Je souhaite utiliser des setters sur plusieurs méthodes d'administration, telles que update. Pour ce faire, j'ai créé un type de méthode qui peut être associé à d'autres méthodes.

Dois-je utiliser l'interface au lieu de func type ?

type adminapi struct {
}

type toadminctx func(ctx context.context, req interface{}) (interface{}, error)

func (a adminapi) adminm2msetter(s toadminctx) toadminctx {
    return func(ctx context.context, arg interface{}) (interface{}, error) {
        m2mprincipal, _ := a.getm2mprincipal(ctx)
        ctxm2m := extlib.setprincipal(ctx, m2mprincipal)
        return s(ctxm2m, arg)
    }
}

func (a adminapi) update(ctx context.context, req *reqtype) (resptype, error) {}

updateWithAdminCtx := a.adminAPI.AdminM2MSetter(s.adminAPI.Update)
// ERROR => cannot use s.adminAPI.Update (value of type func(ctx 
// context.Context, req *ReqType) (RespType, error)) as grpcAdmin.ToGetAdminCtx value in 
// argument to s.adminAPI.AdminM2MSetter

_, err := updateWithAdminCtx(ctx context.Context, req *ReqType)

Solution de contournement

Je pense que l'erreur que vous obtenez est explicite :

a.adminapi.adminm2msetter(s.adminapi.update)

Appelez maintenant

func (a adminapi) adminm2msetter(s toadminctx) toadminctx {

Incoming s.adminapi.update 作为参数，预计类型为 toadminctx. Votre définition de ce type est :

type toadminctx func(ctx context.context, req interface{}) (interface{}, error)

Mais le deuxième paramètre de votre fonction update 函数的第二个参数是 *reqtype，其第一个返回值是 resptype 值，因此 update 不是 toadminctx。 toadminctx 函数类型是可以使用上下文和字面上的任何类型调用的函数。您的 update 函数不能保证在 toadminctx est *reqtype et sa première valeur de retour est la valeur resptype, donc

n'est pas toadminctx . Le type de fonction toadminctx est une fonction qui peut être appelée en utilisant le contexte et littéralement n'importe quel type. Il n'est pas garanti que votre fonction

fonctionne dans tous les cas où la fonction toadminctx le peut. ctx

Ce que vous recherchez, c'est un moyen de "envelopper" n'importe quelle fonction, d'ajouter du travail sur les paramètres

(peut-être en définissant certaines valeurs), puis de transmettre l'appel. Avant la version 1.19, nous faisions cela en ajoutant une sorte de type de wrapper comme celui-ci : update

type wrapper struct {
    updatereqtype *reqtype
    anothertype *reqtype2 // for some other call you want to wrap
}

Modifiez toutes les fonctions associées telles que les fonctions

pour prendre des types d'arguments wrapper :

func (a adminapi) update(ctx context.context, req wrapper) (resp, error) {
    realreq := req.updatereqtype // get the actual request used here
}

Les types de réponses seront enveloppés et/ou combinés de la même manière. adminm2msetter

Maintenant, go prend en charge les génériques et ils sont très utiles dans ce cas, modifions la fonction

pour qu'elle ressemble à ceci : update

func adminm2msetter[t any, r any](s func(context.context, t) (r, error)) func(context.context, t) (r, error) {
    return func (ctx context.context, arg t) (r, error) {
        m2mprincipal, _ := a.getm2mprincipal(ctx)
        ctxm2m := extlib.setprincipal(ctx, m2mprincipal)
        return s(ctxm2m, arg)
    }
}

De cette façon, nous n'avons besoin de définir cette fonction qu'une seule fois et de nous fier plutôt au compilateur pour générer une fonction sur mesure pour tous les types dont nous avons besoin. Pour la fonction

, nous procédons comme suit : update 函数使用的特定类型替换通用 t 和 r 类型。因为我真的不知道你想以这种方式包装什么函数，所以我使用了 t any, r any

a.adminapi.adminm2msetter[*reqtype, resptype](s.adminapi.update)

Remplace essentiellement les types génériques t et r par les types spécifiques utilisés par la fonction

. Comme je ne sais pas vraiment quelle fonction vous voulez envelopper de cette façon, j'ai utilisé t any, r any, mais comme il me semble que vous essayez d'envelopper une sorte de gestionnaire de requêtes, donc vous pouvez créer vos propres contraintes : [t any, r any] 替换为 [t requests, r responses]

type Requests interface {
    *ReqType1 | *ReqType2 | *ReqType3 // and so on
}
type Responses interface {
    Resp1 | Resp2 | Resp3
}

Ajoutez simplement 🎜🎜

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!