Wie rufe ich Funktionen in Golang auf?

Die Methode zum Aufrufen einer Funktion in Golang: Verwenden Sie eine Kartenvariable, um die Zeichenfolge explizit mit der Funktion zu verknüpfen, und rufen Sie das Funktionsobjekt über [funcs["foo"]] ab. Der Code lautet [funcs := map[string ]interface{} „foo“: foo】.

Die Methode zum Aufrufen einer Funktion in Golang:

Anwendungsszenario

Wir kennen a Funktionsname, Stellen Sie den Funktionsnamen durch eine Zeichenfolgenvariable dar und wie Sie dann die Funktion dieser Funktion aufrufen.

func foo() {
  fmt.Println("in foo");
}
var funcname string = "foo"
func callFunc(funcname string) {
    ...
}
callFunc(funcname)

Die folgende Frage ist, wie wir den Inhalt von callFunc() implementieren, um die erforderliche Funktion abzuschließen.

Die derzeit bekannten Methoden scheinen nicht zu funktionieren. Es ist unmöglich, ein Funktionsobjekt anhand des Namens aus der globalen Domäne abzurufen.
(Das Gleiche gilt für Variablen. Sie können ein Variablenobjekt nicht anhand des Namens aus dem globalen Bereich abrufen.)

Eine praktikable Möglichkeit

Verwenden Sie eine Kartenvariable, um die Zeichenfolge und die explizit zu kombinieren Funktion (Variablen) sind verknüpft:

   funcs := map[string]interface{} {
            "foo": foo,
    }

, damit wir das Funktionsobjekt über funcs["foo"] abrufen und dann die Funktion ausführen können.

Beispiele für Funktionsoperationen

Im Folgenden finden Sie ein Beispiel für einen Funktionsaufruf, einschließlich der Übergabe von Parametern und der Verarbeitung von Rückgabewerten.

package main
import "fmt"
import "reflect"
import "errors"
type MyStruct struct {
    i int
    s string
}
func foo0() int {
    fmt.Println("running foo0: ")
    return 100
}
func foo1(a int) (string, string) {
    fmt.Println("running foo1: ", a)
    return "aaaa", "bbb"
}
func foo2(a, b int, c string) MyStruct {
    fmt.Println("running foo2: ", a, b, c)
    return MyStruct{10, "ccc"}
}
func Call(m map[string]interface{}, name string, params ... interface{}) (result []reflect.Value, err error) {
    f := reflect.ValueOf(m[name])
    if len(params) != f.Type().NumIn() {
        err = errors.New("The number of params is not adapted.")
        return
    }
    in := make([]reflect.Value, len(params))
    for k, param := range params {
        in[k] = reflect.ValueOf(param)
    }
    result = f.Call(in)
    return
}
func main() {
    funcs := map[string]interface{} {
            "foo0": foo0,
            "foo1": foo1,
            "foo2": foo2,
    }
    // call foo0
    if result, err := Call(funcs, "foo0"); err == nil {
        for _, r := range result {
            fmt.Printf("  return: type=%v, value=[%d]\n", r.Type(), r.Int())
        }
    }
    // call foo1
    if result, err := Call(funcs, "foo1", 1); err == nil {
        for _, r := range result {
            fmt.Printf("  return: type=%v, value=[%s]\n", r.Type(), r.String())
        }
    }
    // call foo2
    if result, err := Call(funcs, "foo2", 1, 2, "aa"); err == nil {
        for _, r := range result {
            fmt.Printf("  return: type=%v, value=[%+v]\n", r.Type(), r.Interface().(MyStruct))
        }
    }
}

Kompilieren und ausführen:

running foo0: 
  return: type=int, value=[100]
running foo1:  1
  return: type=string, value=[aaaa]
  return: type=string, value=[bbb]
running foo2:  1 2 aa
  return: type=main.MyStruct, value=[{i:10 s:ccc}]

Verwandte Lernempfehlungen: Go-Sprachtutorial

Das obige ist der detaillierte Inhalt vonWie rufe ich Funktionen in Golang auf?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!