How to call functions in golang?

Golang’s method of calling a function: use a map variable to explicitly associate the string with the function, and obtain the function object through [funcs["foo"]], the code is [funcs := map[string ]interface{} "foo": foo].

Golang’s method of calling a function:

Application scenario

We know a function name, Represent the function name through a string variable, and then how to call the function of this function.

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

The following question is how do we implement the content of callFunc() to complete the required function.

The currently known methods do not seem to work. It is impossible to obtain a function object by name from the global domain.
(The same is true for variables, you cannot get a variable object by name from the global domain)

Feasible methods

Use a map variable to explicitly combine the string with the function ( Variables) are associated:

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

In this way, we can get the function object through funcs["foo"], and then we can operate the function.

Example of function operation

The following is an example of a function call, including the passing of parameters and the processing of return values.

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

Compile and run:

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

Related learning recommendations: Go language tutorial

The above is the detailed content of How to call functions in golang?. For more information, please follow other related articles on the PHP Chinese website!