Comment appeler des fonctions en Golang ?

La méthode d'appel d'une fonction en golang : utilisez une variable map pour associer explicitement la chaîne à la fonction, et obtenez l'objet fonction via [funcs["foo"]], le code est [funcs := map[string ]interface{} "foo": foo】.

La méthode d'appel d'une fonction en golang :

Scénario d'application

On connaît un nom de la fonction, représente le nom de la fonction via une variable de chaîne, puis comment appeler la fonction de cette fonction.

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

La question suivante est de savoir comment implémenter le contenu de callFunc() pour remplir la fonction requise.

Les méthodes actuellement connues ne semblent pas fonctionner. Il est impossible d'obtenir un objet fonction par son nom depuis le domaine global.
(La même chose est vraie pour les variables, vous ne pouvez pas obtenir un objet variable par son nom à partir de la portée globale)

Une manière réalisable

Utilisez une variable map pour combiner explicitement la chaîne et le fonction (Variables) sont associées :

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

afin que nous puissions faire passer l'objet fonction via funcs["foo"] puis faire fonctionner la fonction.

Exemples d'opérations de fonction

Ce qui suit est un exemple d'appel de fonction, y compris la transmission de paramètres et le traitement des valeurs de retour.

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

Compilez et exécutez :

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

Recommandations d'apprentissage associées : Tutoriel de langue Go

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!