Wie erstelle ich einen Funktions-Wrapper in Go to Inject Code vor und nach der Ausführung?

Funktions-Wrapper in Go

Frage:

Wie kann ich einen Funktions-Wrapper in erstellen? Gehen Sie zum Einfügen von Code vor und nach einer Funktion Ausführung?

Antwort:

In Go ist es möglich, einen Funktions-Wrapper zu erstellen, der eine Funktion als Argument akzeptiert und einen neuen Funktionswert zurückgibt. Dies ermöglicht das Einfügen von Code vor und nach dem Aufruf der umschlossenen Funktion.

Hier ist ein Beispiel einer Wrapper-Funktion:

func funcWrapper(myFunc interface{}) {
    fmt.Println("Before")
    // Call myFunc
    fmt.Println("After")
}

Umschlossene Funktion mit Signatur:

Wenn Sie die Signatur der zu umschließenden Funktion kennen, können Sie eine Wrapper-Funktion erstellen, die einen Funktionswert dieses Typs annimmt und einen anderen Funktionswert zurückgibt vom gleichen Typ. Dies wird unten beispielhaft veranschaulicht:

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
    }
}

Unterstützung mehrerer Funktionstypen:

Um mehrere Funktionstypen zu unterstützen, können Sie für jeden einzelnen Typ separate Wrapper-Funktionen erstellen:

func wrap(f func()) func() {
    return func() {
        fmt.Println("Before func()")
        f()
        fmt.Println("After func()")
    }
}

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

Verwendung eines generischen Wrappers Reflexion:

Obwohl es in Go keine Generika gibt, ist ein generischerer Ansatz mithilfe von Reflexion möglich:

func wrap(f interface{}) interface{} {
    switch f2 := f.(type) {
    case func(i int) (ret int):
        return func(i int) (ret int) {
            fmt.Println("Before func(i int) (ret int), i =", i)
            ret = f2(i)
            fmt.Println("After func(i int) (ret int), ret =", ret)
            return
        }
    case func():
        return func() {
            fmt.Println("Before func()")
            f2()
            fmt.Println("After func()")
        }
    }
    return nil
}

Dieser Ansatz verwendet jedoch einen Interface{}-Rückgabetyp und erfordert Typzusicherungen, wenn es verwenden.

Beispiel Verwendung:

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

Ausgabe:

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

Das obige ist der detaillierte Inhalt vonWie erstelle ich einen Funktions-Wrapper in Go to Inject Code vor und nach der Ausführung?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!