Golang如何实现动态调用匿名函数_Golang 匿名函数动态调用实践

package main

import (
    "fmt"
    "reflect"
)

// 定义一个通用的函数类型，以便反射时更方便处理，
// 但实际操作中，反射可以处理任何函数签名
type DynamicFunc func(args ...interface{}) (interface{}, error)

func main() {
    // 存储匿名函数的映射
    // 注意：这里为了简化，我们存储了不同签名的匿名函数
    // 实际应用中，你可能需要更严格的类型定义或更复杂的反射逻辑
    funcRegistry := make(map[string]interface{})

    // 注册一个不带参数，返回字符串的匿名函数
    funcRegistry["greet"] = func() string {
        return "Hello, dynamic world!"
    }

    // 注册一个带一个字符串参数，返回拼接字符串的匿名函数
    funcRegistry["echo"] = func(msg string) string {
        return "Echoing: " + msg
    }

    // 注册一个带两个整数参数，返回它们的和的匿名函数
    funcRegistry["add"] = func(a, b int) int {
        return a + b
    }

    // 尝试动态调用这些函数
    callDynamicFunc(funcRegistry, "greet")
    callDynamicFunc(funcRegistry, "echo", "Golang rocks!")
    callDynamicFunc(funcRegistry, "add", 10, 20)
    callDynamicFunc(funcRegistry, "nonExistentFunc") // 尝试调用不存在的函数
    callDynamicFunc(funcRegistry, "echo", 123)        // 参数类型不匹配
}

// callDynamicFunc 是一个通用的动态函数调用器
func callDynamicFunc(registry map[string]interface{}, funcName string, args ...interface{}) {
    fn, ok := registry[funcName]
    if !ok {
        fmt.Printf("Error: Function '%s' not found.\n", funcName)
        return
    }

    // 将函数转换为reflect.Value
    fnValue := reflect.ValueOf(fn)

    // 检查是否真的是一个函数
    if fnValue.Kind() != reflect.Func {
        fmt.Printf("Error: '%s' is not a function.\n", funcName)
        return
    }

    // 准备参数
    in := make([]reflect.Value, len(args))
    for i, arg := range args {
        // 这里需要注意类型匹配，如果类型不匹配，reflect.ValueOf会panic
        // 或者在Call方法时报错。生产环境中需要更严谨的类型检查和转换
        in[i] = reflect.ValueOf(arg)
    }

    // 检查参数数量是否匹配
    if fnValue.Type().NumIn() != len(in) {
        fmt.Printf("Error calling '%s': expected %d arguments, got %d.\n",
            funcName, fnValue.Type().NumIn(), len(in))
        return
    }

    // 尝试调用函数
    // 注意：这里没有进行参数类型的严格匹配检查，如果类型不兼容，Call会panic
    // 实际应用中，你需要遍历fnValue.Type().In(i)来获取期望的参数类型，并进行转换
    defer func() {
        if r := recover(); r != nil {
            fmt.Printf("Panic during calling '%s': %v. Possible argument type mismatch.\n", funcName, r)
        }
    }()

    out := fnValue.Call(in)

    // 处理返回值
    if len(out) > 0 {
        // 同样，这里只是简单打印第一个返回值，实际应用中可能需要处理多个返回值
        // 并且根据返回值的具体类型进行进一步操作
        fmt.Printf("Function '%s' returned: %v\n", funcName, out[0].Interface())
    } else {
        fmt.Printf("Function '%s' executed, no return value.\n", funcName)
    }
}

package main

import (
    "fmt"
    "reflect"
)

func main() {
    // 匿名函数，带两个int参数，返回一个int
    addFunc := func(a, b int) int {
        fmt.Printf("Inside addFunc: %d + %d\n", a, b)
        return a + b
    }

    // 匿名函数，带一个string参数，返回一个string
    greetFunc := func(name string) string {
        fmt.Printf("Inside greetFunc with name: %s\n", name)
        return "Hello, " + name + "!"
    }

    // 1. 动态调用 addFunc
    fmt.Println("--- Calling addFunc dynamically ---")
    // 将函数包装为 interface{}
    addFnInterface := interface{}(addFunc)
    fnValue := reflect.ValueOf(addFnInterface)

    // 检查是否是函数类型
    if fnValue.Kind() != reflect.Func {
        fmt.Println("Error: not a function")
        return
    }

    // 准备参数
    // 注意：这里需要确保参数类型与函数期望的类型匹配
    // 否则 reflect.ValueOf(arg) 或 Call 方法会panic
    args := []reflect.Value{
        reflect.ValueOf(100),
        reflect.ValueOf(200),
    }

    // 调用函数
    results := fnValue.Call(args)

    // 处理返回值
    if len(results) > 0 {
        sum := results[0].Interface().(int) // 将 reflect.Value 转换回 int
        fmt.Printf("Result of addFunc: %d\n", sum)
    }

    // 2. 动态调用 greetFunc
    fmt.Println("\n--- Calling greetFunc dynamically ---")
    greetFnInterface := interface{}(greetFunc)
    greetFnValue := reflect.ValueOf(greetFnInterface)

    greetArgs := []reflect.Value{
        reflect.ValueOf("Alice"),
    }

    greetResults := greetFnValue.Call(greetArgs)
    if len(greetResults) > 0 {
        greeting := greetResults[0].Interface().(string)
        fmt.Printf("Result of greetFunc: %s\n", greeting)
    }

    // 3. 演示参数类型不匹配的场景 (会导致panic)
    fmt.Println("\n--- Demonstrating argument type mismatch (will panic) ---")
    defer func() {
        if r := recover(); r != nil {
            fmt.Printf("Recovered from panic: %v\n", r)
        }
    }()

    badArgs := []reflect.Value{
        reflect.ValueOf("not an int"), // 期望 int，但传入 string
        reflect.ValueOf(50),
    }
    // 这行代码可能会因为参数类型不匹配而panic
    // 在生产环境中，你需要先检查 fnValue.Type().In(i) 来获取期望类型，并进行类型转换
    // _ = fnValue.Call(badArgs) // 暂时注释掉，避免直接导致程序崩溃
    fmt.Println("Attempted to call addFunc with wrong argument type, should have panicked.")
}