Go动态运行函数

package main
import (
    "fmt"
    "os"
)
var f func() string
//根据传入的参数动态执行不同的函数
func init() {
    if len(os.Args) > 1 {
        if os.Args[1] == "a" {
            f = func() string {
                return "bingo"
            }
        } else {
            f = func() string {
                return os.Args[1]
            }
        }
    }
}

func main() {
    fmt.Println(f())
}

package main 
import (
    "fmt"
    "strings"
)

//对相同函数签名的函数进行动态调用
func double(data string) string {
    return data + data
}
func upper(data string) string {
    return strings.ToUpper(data)
}

var command = map[string]func(data string) string {
    "double":double, "upper":upper }

func call(com, data string) string {
    if function, ok := command[com]; ok {
        return function(data)
    }
    return  ""
}

func main() {
    var com string = "upper"
    var data string = "abcd"
    fmt.Println(call(com, data))

    com = "double"
    fmt.Println(call(com, data))

}

package main
import (
    "fmt"
    "reflect"
)

//实现对不同函数签名的函数动态调用
//简单起见，函数都没有带返回值.
func print(data string) {
    fmt.Println("print:", data)
}

func add(a, b int) {
    fmt.Println("add: ", a+b)
}
var command = map[string]interface{} {
    "print":print, "add":add}

func call(name string, params ...interface{}) {
    //获取反射对象
    f := reflect.ValueOf(command[name])
    //判断函数参数和传入的参数是否相等
    if len(params) != f.Type().NumIn() {
        return
    }
    //然后将传入参数转为反射类型切片
    in := make([]reflect.Value, len(params))
    for k, param := range params {
        in[k] = reflect.ValueOf(param)
    }
    //利用函数反射对象的call方法调用函数.
    f.Call(in)
}

func main() {
    call("print", "abcdef")
    call("add", 7, 9)
}