Go语言反射：将reflect.Value安全转换回具体类型

package main

import (
    "fmt"
    "reflect"
)

type Cat struct {
    Age int
}

func main() {
    myCat := Cat{Age: 3}
    catValue := reflect.ValueOf(myCat)

    fmt.Printf("原始 reflect.Value 类型: %v\n", catValue.Type()) // 输出: main.Cat

    // 错误的转换尝试 (编译时错误)
    // fmt.Println(Cat(catValue).Age)    // 编译错误：cannot convert catValue (type reflect.Value) to type Cat
    // fmt.Println((catValue.(Cat)).Age) // 编译错误：invalid type assertion: catValue.(Cat) (non-interface type reflect.Value on left)
}

package main

import (
    "fmt"
    "reflect"
)

// Cat 结构体定义
type Cat struct {
    Age  int
    Name string
}

// MyInt 自定义整数类型
type MyInt int

func main() {
    // 示例一：将 reflect.Value 转换为结构体
    myCat := Cat{Age: 3, Name: "Whiskers"}
    catValue := reflect.ValueOf(myCat)

    fmt.Printf("--- 结构体转换示例 ---\n")
    fmt.Printf("原始 reflect.Value 类型: %v\n", catValue.Type())

    // 正确的转换方法：使用 Interface() 和带 ok 的类型断言
    if concreteCat, ok := catValue.Interface().(Cat); ok {
        fmt.Printf("成功转换为 Cat 类型，年龄: %d, 名字: %s\n", concreteCat.Age, concreteCat.Name)
        // 此时 concreteCat 是一个 Cat 类型的变量，可以像普通变量一样操作
        concreteCat.Age = 4
        fmt.Printf("修改后的 Cat 变量年龄: %d\n", concreteCat.Age)
        // 注意：这里修改的是 concreteCat 的副本，不会影响 myCat
        fmt.Printf("原始 myCat 的年龄: %d\n", myCat.Age) // 仍然是 3
    } else {
        fmt.Println("类型转换失败：reflect.Value 无法转换为 Cat 类型")
    }

    // 示例二：将 reflect.Value 转换为自定义基本类型
    fmt.Printf("\n--- 自定义基本类型转换示例 ---\n")
    var x MyInt = 7
    myIntValue := reflect.ValueOf(x)

    fmt.Printf("原始 reflect.Value 类型: %v\n", myIntValue.Type())

    // 获取 interface{} 值
    interfacedValue := myIntValue.Interface()

    // 尝试断言为 MyInt
    if intVal, ok := interfacedValue.(MyInt); ok {
        fmt.Printf("成功转换为 MyInt: %d\n", intVal)
        // 如果需要转换为其他数值类型（如 float64），需要进行显式转换
        fmt.Printf("MyInt 显式转换为 float64: %f\n", float64(intVal))
    } else {
        fmt.Printf("类型转换失败：无法将 reflect.Value 转换为 MyInt 类型。实际类型是: %T\n", interfacedValue)
    }

    // 尝试断言为不匹配的类型 (例如 int 或 float64)，将会失败
    if _, ok := interfacedValue.(int); !ok {
        fmt.Println("尝试将 MyInt 断言为 int 失败，符合预期。")
    }
    if _, ok := interfacedValue.(float64); !ok {
        fmt.Println("尝试将 MyInt 断言为 float64 失败，符合预期。")
    }

    // 示例三：不带 ok 的类型断言 (如果类型不匹配会 panic)
    // 警告：不推荐在不确定类型时使用此方式
    // var anotherCat Cat
    // anotherCatUnsafe := reflect.ValueOf(anotherCat).Interface().(Cat) // 如果类型不匹配会 panic
    // fmt.Printf("不带ok的转换：年龄: %d\n", anotherCatUnsafe.Age)
}