Golang反射获取函数参数与返回值信息

reflect

reflect.Type

reflect.TypeOf

NumIn()

In(i)

NumOut()

Out(i)

reflect.TypeOf

reflect.Type

package main

import (
    "fmt"
    "reflect"
)

// 定义一个示例函数
func MyExampleFunc(id int, name string, scores ...float64) (string, error) {
    if id < 0 {
        return "", fmt.Errorf("ID不能为负数：%d", id)
    }
    totalScore := 0.0
    for _, score := range scores {
        totalScore += score
    }
    return fmt.Sprintf("用户ID: %d, 姓名: %s, 总分: %.2f", id, name, totalScore), nil
}

func main() {
    // 获取函数的reflect.Type
    funcType := reflect.TypeOf(MyExampleFunc)

    fmt.Println("--- 函数签名分析 ---")

    // 获取参数信息
    fmt.Printf("参数数量: %d\n", funcType.NumIn())
    for i := 0; i < funcType.NumIn(); i++ {
        paramType := funcType.In(i)
        fmt.Printf("  参数 %d: 类型为 %s", i+1, paramType.String())
        // 检查是否是可变参数
        if funcType.IsVariadic() && i == funcType.NumIn()-1 {
            // 可变参数在reflect中会被表示为一个切片类型，例如 `[]float64`
            // 如果要获取其元素类型，需要进一步检查
            fmt.Printf(" (可变参数，其元素类型为 %s)", paramType.Elem().String())
        }
        fmt.Println()
    }

    // 获取返回值信息
    fmt.Printf("返回值数量: %d\n", funcType.NumOut())
    for i := 0; i < funcType.NumOut(); i++ {
        returnType := funcType.Out(i)
        fmt.Printf("  返回值 %d: 类型为 %s\n", i+1, returnType.String())
    }

    fmt.Println("\n--- 进一步探索：匿名函数 ---")
    // 匿名函数同样适用
    anonFunc := func(a, b int) (sum int, mul int) {
        sum = a + b
        mul = a * b
        return
    }
    anonFuncType := reflect.TypeOf(anonFunc)
    fmt.Printf("匿名函数参数数量: %d, 返回值数量: %d\n", anonFuncType.NumIn(), anonFuncType.NumOut())
    fmt.Printf("  第一个参数类型: %s\n", anonFuncType.In(0))
    fmt.Printf("  第一个返回值类型: %s\n", anonFuncType.Out(0))
}

MyExampleFunc

int

string

[]float64

string

error

...T

[]T

reflect.Value

Call

package main

import (
    "fmt"
    "reflect"
)

// 定义一个示例函数
func Add(a, b int) (int, error) {
    if a < 0 || b < 0 {
        return 0, fmt.Errorf("参数不能为负数")
    }
    return a + b, nil
}

// 另一个示例函数
func Greet(name string) string {
    return "Hello, " + name + "!"
}

func main() {
    fmt.Println("--- 动态调用 Add 函数 ---")
    // 获取函数的reflect.Value
    addFuncValue := reflect.ValueOf(Add)

    // 准备参数：需要将Go类型的值转换为reflect.Value
    // 对应 Add(a, b int)
    args := []reflect.Value{
        reflect.ValueOf(10), // a
        reflect.ValueOf(20), // b
    }

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

    // 处理返回值：将reflect.Value转换回Go类型
    // 对应 (int, error)
    sum := results[0].Interface().(int)
    var err error
    if !results[1].IsNil() { // 检查 error 是否为 nil
        err = results[1].Interface().(error)
    }

    if err != nil {
        fmt.Printf("调用 Add 失败: %v\n", err)
    } else {
        fmt.Printf("调用 Add(10, 20) 结果: %d\n", sum)
    }

    fmt.Println("\n--- 动态调用 Greet 函数 ---")
    greetFuncValue := reflect.ValueOf(Greet)
    greetArgs := []reflect.Value{
        reflect.ValueOf("Alice"),
    }
    greetResults := greetFuncValue.Call(greetArgs)
    message := greetResults[0].Interface().(string)
    fmt.Printf("调用 Greet(\"Alice\") 结果: %s\n", message)

    fmt.Println("\n--- 错误处理示例：参数类型不匹配 ---")
    // 尝试用错误类型的参数调用 Add
    invalidArgs := []reflect.Value{
        reflect.ValueOf("not_an_int"), // 错误的参数类型
        reflect.ValueOf(5),
    }
    // 这里的错误不会在 Call 层面直接抛出，而是在准备参数时就应该避免
    // 如果你尝试用 reflect.ValueOf("not_an_int") 去匹配 int 类型，
    // 编译器不会报错，但 Call 会在运行时 panic，因为类型不兼容
    // 为了演示，我们故意创建一个会导致 panic 的场景（这里不直接运行，因为会崩溃）
    // fmt.Println("尝试用错误参数调用 Add (会导致panic):")
    // defer func() {
    //  if r := recover(); r != nil {
    //      fmt.Printf("捕获到运行时错误: %v\n", r)
    //  }
    // }()
    // addFuncValue.Call(invalidArgs) // 这行代码会引发 panic: reflect.Value.Call: wrong argument type
    fmt.Println("注意：如果参数类型不匹配，reflect.Value.Call 会在运行时 panic。")
    fmt.Println("在实际应用中，你需要提前检查参数类型是否与函数签名匹配。")
    fmt.Println("例如：")
    // 检查参数类型匹配
    funcType := addFuncValue.Type()
    if len(invalidArgs) != funcType.NumIn() {
        fmt.Println("  参数数量不匹配！")
    } else {
        for i := 0; i < funcType.NumIn(); i++ {
            if !invalidArgs[i].Type().AssignableTo(funcType.In(i)) {
                fmt.Printf("  参数 %d 类型不匹配：期望 %s, 得到 %s\n", i, funcType.In(i), invalidArgs[i].Type())
                // 这里应该返回错误或进行其他处理
            }
        }
    }

}