How Can Function Wrappers in Go Inject Code Before and After Function Execution?

Function Wrappers in Go: Injecting Code into Function Executions

Creating function wrappers allows developers to enhance existing functions by injecting code before and after their execution. In Go, this technique requires knowing the signature of the function being wrapped and returning a function value of the same type.

---

In the following example, we define a wrapper function wrap that accepts a function f and returns a new function wrapped in wrap. This new function has the same signature as f. Before and after executing f, wrap prints messages to the 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
    }
}

To illustrate this, we have a function called myfunc that doubles the input number:

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

---

By wrapping myfunc with the wrap function, we can append our own functionality.

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

Output:

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

Supporting Multiple Function Types

Since Go lacks generics, a specific wrapper function must be created for each function type to be supported. Alternatively, a wrapper function can be written to handle multiple function types using reflect.MakeFunc(), although this approach may introduce complexity.

For functions with no parameters or return values, the wrap function can be slightly modified:

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

In conclusion, function wrappers in Go provide a means of modifying the behavior of existing functions without altering their source code. Developers can customize these wrappers to meet specific requirements and enhance code flexibility.

The above is the detailed content of How Can Function Wrappers in Go Inject Code Before and After Function Execution?. For more information, please follow other related articles on the PHP Chinese website!