Golang反射：理解与解决接口包裹结构体值时字段不可设置的问题

package main

import (
    "fmt"
    "reflect"
)

type A struct {
    Str string
}

func main() {
    var x interface{} = A{Str: "Hello"}

    // 尝试通过反射修改 x 中 A 结构体的 Str 字段
    // 以下尝试都会导致 panic 或 CanSet() 返回 false
    // fmt.Println(reflect.ValueOf(&x).Field(0).CanSet()) // panic: reflect: call of reflect.Value.Field on ptr Value
    // fmt.Println(reflect.ValueOf(&x).Elem().Field(0).CanSet()) // panic: reflect: call of reflect.Value.Field on interface Value
    fmt.Println(reflect.ValueOf(&x).Elem().Elem().Field(0).CanSet()) // 输出 false
    // reflect.ValueOf(&x).Elem().Elem().Field(0).SetString("Bye") // panic: reflect: reflect.Value.SetString using unaddressable value

    fmt.Printf("原始接口值 x: %+v\n", x) // 输出 {Str:Hello}
}

package main

import (
    "fmt"
    "reflect"
)

type A struct {
    Str string
}

func main() {
    var z interface{} = &A{Str: "Hello"} // 接口包裹的是结构体 A 的指针

    // 获取 z 的 reflect.Value
    val := reflect.ValueOf(z)
    // Elem() 解引用指针，得到指向的 A 结构体
    // 这个 A 结构体的 reflect.Value 是可寻址的
    elem := val.Elem()

    // 获取 Str 字段
    field := elem.FieldByName("Str")

    // 检查是否可设置
    fmt.Println(field.CanSet()) // 输出 true

    // 修改字段值
    if field.IsValid() && field.CanSet() {
        field.SetString("Bye")
    }

    fmt.Printf("修改后的接口值 z: %+v\n", z) // 输出 &{Str:Bye}
    fmt.Printf("修改后的结构体值: %+v\n", z.(*A)) // 输出 &{Str:Bye}
}

package main

import (
    "fmt"
)

type A struct {
    Str string
}

func main() {
    var x interface{} = A{Str: "Hello"} // 接口包裹的是结构体 A 的值

    // 1. 将接口中的值取出（进行类型断言，会得到值的副本）
    a := x.(A)

    // 2. 修改这个副本
    a.Str = "Bye"

    // 3. 将修改后的副本重新赋值回接口
    x = a

    fmt.Printf("修改后的接口值 x: %+v\n", x) // 输出 {Str:Bye}
    fmt.Printf("修改后的结构体值: %+v\n", x.(A)) // 输出 {Str:Bye}
}

package main

import (
    "fmt"
    "reflect"
)

type A struct {
    Str string
    Num int
}

func main() {
    var originalVal interface{} = A{Str: "Initial", Num: 10}

    // 获取原始值的类型
    typ := reflect.TypeOf(originalVal)

    // 使用 reflect.New 创建一个指向该类型新实例的指针
    // newPtr 是一个 *A 类型的 reflect.Value
    newPtr := reflect.New(typ)

    // 获取新实例本身（解引用指针）
    // newVal 是一个 A 类型的 reflect.Value，且它是可寻址的
    newVal := newPtr.Elem()

    fmt.Println("新创建实例的 CanSet():", newVal.CanSet()) // 输出 true

    // 现在可以设置 newVal 的字段了
    if newVal.Kind() == reflect.Struct {
        // 设置 Str 字段
        strField := newVal.FieldByName("Str")
        if strField.IsValid() && strField.CanSet() {
            strField.SetString("Modified via reflect.New")
        }

        // 设置 Num 字段
        numField := newVal.FieldByName("Num")
        if numField.IsValid() && numField.CanSet() {
            numField.SetInt(200)
        }
    }

    // 将修改后的新实例转换回接口类型
    modifiedInstance := newVal.Interface()

    fmt.Printf("通过 reflect.New 创建并修改的实例: %+v\n", modifiedInstance)
    // 输出: 通过 reflect.New 创建并修改的实例: {Str:Modified via reflect.New Num:200}

    // 注意：这并未修改 originalVal，而是创建了一个新的、可修改的实例
    fmt.Printf("原始接口值 originalVal 保持不变: %+v\n", originalVal)
    // 输出: 原始接口值 originalVal 保持不变: {Str:Initial Num:10}
}