Go语言中利用反射机制调用方法并正确处理其返回值

func (v Value) Call(in []Value) []Value

package main

import (
    "fmt"
    "reflect"
)

type T struct{}

func (t *T) Bar(ms *MyStruct, p *Person) int {
    return p.Age
}

type MyStruct struct {
    id int
}

type Person struct {
    Name string
    Age  int
}

func main() {
    var t *T
    // 尝试直接赋值，会导致编译错误
    // var ans int
    // ans = reflect.ValueOf(t).MethodByName("Bar").Call([]reflect.Value{reflect.ValueOf(&MyStruct{15}), reflect.ValueOf(&Person{"Dexter", 15})})
    // 错误信息：cannot use reflect.ValueOf(t).MethodByName("Bar").Call([]reflect.Value literal) (type []reflect.Value) as type int in assignment
}

package main

import (
    "fmt"
    "reflect"
)

// 定义一个结构体T
type T struct{}

// T的方法Foo，不带参数，无返回值
func (t *T) Foo() {
    fmt.Println("Foo method called")
}

// T的方法Bar，带两个结构体指针参数，返回一个int类型值
func (t *T) Bar(ms *MyStruct, p *Person) int {
    fmt.Printf("Bar method called with MyStruct ID: %d, Person Name: %s\n", ms.id, p.Name)
    return p.Age
}

// 辅助结构体MyStruct
type MyStruct struct {
    id int
}

// 辅助结构体Person
type Person struct {
    Name string
    Age  int
}

func main() {
    // 实例化T
    var t *T = &T{} // 确保t不是nil，否则MethodByName会panic

    // 1. 调用无返回值的方法Foo
    fmt.Println("--- Calling Foo method ---")
    methodFoo := reflect.ValueOf(t).MethodByName("Foo")
    if !methodFoo.IsValid() {
        fmt.Println("Method Foo not found or not callable.")
        return
    }
    methodFoo.Call([]reflect.Value{}) // 无参数，无返回值

    // 2. 调用有返回值的方法Bar
    fmt.Println("\n--- Calling Bar method and getting return value ---")
    methodBar := reflect.ValueOf(t).MethodByName("Bar")
    if !methodBar.IsValid() {
        fmt.Println("Method Bar not found or not callable.")
        return
    }

    // 准备方法参数
    arg1 := reflect.ValueOf(&MyStruct{id: 15})
    arg2 := reflect.ValueOf(&Person{Name: "Dexter", Age: 30}) // 将Age改为30以示区别

    // 调用方法，返回一个[]reflect.Value切片
    returnValues := methodBar.Call([]reflect.Value{arg1, arg2})

    // 检查返回值切片是否为空
    if len(returnValues) == 0 {
        fmt.Println("Method Bar returned no values.")
        return
    }

    // 获取第一个返回值（如果方法只返回一个值）
    // 并使用Int()方法将其转换为int64类型
    var ans int64 = returnValues[0].Int()
    fmt.Printf("Returned value from Bar method (int64): %d\n", ans)

    // 如果需要精确的int类型，可能需要再次转换
    var finalAns int = int(ans)
    fmt.Printf("Returned value from Bar method (int): %d\n", finalAns)

    // 示例：如果方法返回字符串
    // func (t *T) GetName() string { return "Reflected Name" }
    // ...
    // nameValue := reflect.ValueOf(t).MethodByName("GetName").Call([]reflect.Value{})[0]
    // name := nameValue.String()
    // fmt.Println("Name:", name)

    // 示例：如果方法返回多个值
    // func (t *T) GetMulti() (int, string) { return 100, "hello" }
    // ...
    // multiValues := reflect.ValueOf(t).MethodByName("GetMulti").Call([]reflect.Value{})
    // if len(multiValues) >= 2 {
    //     val1 := multiValues[0].Int()
    //     val2 := multiValues[1].String()
    //     fmt.Printf("Multi values: %d, %s\n", val1, val2)
    // }
}