Comment les wrappers de fonctions dans Go peuvent-ils injecter du code avant et après l'exécution de la fonction ?

Function Wrappers in Go : injecter du code dans les exécutions de fonctions

La création de wrappers de fonctions permet aux développeurs d'améliorer les fonctions existantes en injectant du code avant et après leur exécution. En Go, cette technique nécessite de connaître la signature de la fonction en cours d'encapsulation et de renvoyer une valeur de fonction du même type.

---

Dans l'exemple suivant, nous définissons une fonction wrapper wrap qui accepte une fonction f et renvoie une nouvelle fonction enveloppée dans wrap. Cette nouvelle fonction a la même signature que f. Avant et après l'exécution de f, wrap imprime des messages sur la console.

func wrap(f func(i int) int) func(i int) int {
    return func(i int) (ret int) {
        fmt.Println("Before, i =", i)
        ret = f(i)
        fmt.Println("After, ret =", ret)
        return
    }
}

Pour illustrer cela, nous avons une fonction appelée myfunc qui double le nombre d'entrée :

func myfunc(i int) int {
    fmt.Println("myfunc called with", i)
    return i * 2
}

---

En enveloppant myfunc avec la fonction wrap, nous pouvons ajouter notre propre fonctionnalité.

wf := wrap(myfunc)
ret := wf(2)
fmt.Println("Returned:", ret)

Sortie :

Before, i = 2
myfunc called with 2
After, ret = 4
Returned: 4

Prise en charge de plusieurs types de fonctions

Étant donné que Go manque de génériques, une fonction wrapper spécifique doit être créée pour chaque type de fonction à prendre en charge. Alternativement, une fonction wrapper peut être écrite pour gérer plusieurs types de fonctions à l'aide de Reflect.MakeFunc(), bien que cette approche puisse introduire de la complexité.

Pour les fonctions sans paramètres ni valeurs de retour, la fonction wrap peut être légèrement modifiée :

func wrap(f interface{}) interface{} {
    switch f2 := f.(type) {
    case func(i int) (ret int):
        // ...
    case func():
        // ...
    }
    return nil
}

En conclusion, les wrappers de fonctions dans Go fournissent un moyen de modifier le comportement des fonctions existantes sans altérer leur code source. Les développeurs peuvent personnaliser ces wrappers pour répondre à des exigences spécifiques et améliorer la flexibilité du code.

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!