Go语言反射：深度解析接口值与结构体字段的修改限制

package main

import (
    "fmt"
    "reflect"
)

type A struct {
    Str string
}

func main() {
    // 场景一：接口包装结构体值
    var x interface{} = A{Str: "Hello"}

    // 尝试直接通过反射修改 x 内部的 A 结构体字段
    // 以下操作均会失败或导致panic：

    // 错误示例1: reflect.ValueOf(&x) 是 *interface{}，对其调用 Field(0) 是错误的
    // reflect.ValueOf(&x).Field(0).SetString("Bye") // panic: reflect: call of reflect.Value.Field on ptr Value

    // 错误示例2: reflect.ValueOf(&x).Elem() 得到的是 interface{} 变量本身，Kind为Interface
    // 对其调用 Field(0) 也是错误的
    // reflect.ValueOf(&x).Elem().Field(0).SetString("Bye") // panic: reflect: call of reflect.Value.Field on interface Value

    // 错误示例3: reflect.ValueOf(&x).Elem().Elem() 得到的是接口内部的动态值 A{Str: "Hello"}
    // 这个 reflect.Value 代表的 A 结构体是不可寻址的，因此其字段也无法设置
    vA := reflect.ValueOf(&x).Elem().Elem()
    fmt.Printf("A 结构体值是否可寻址？ %t\n", vA.CanAddr()) // 输出：false
    fmt.Printf("A.Str 字段是否可设置？ %t\n", vA.Field(0).CanSet()) // 输出：false
    // vA.Field(0).SetString("Bye") // panic: reflect: reflect.Value.SetString using unaddressable value

    fmt.Println("------------------------------------")

    // 场景二：接口包装结构体指针
    var z interface{} = &A{Str: "Hello"}

    // 通过反射修改 z 内部的 *A 指针指向的 A 结构体字段
    // reflect.ValueOf(z) 得到的是 *A 的 reflect.Value (Kind Ptr)
    // .Elem() 解引用得到 A 结构体值的 reflect.Value (Kind Struct)
    // 这个 A 结构体值是可寻址的，因为它是通过指针获得的
    vPtrA := reflect.ValueOf(z)
    vAFromPtr := vPtrA.Elem()
    fmt.Printf("*A 指针是否可寻址？ %t\n", vPtrA.CanAddr()) // 输出：true
    fmt.Printf("A 结构体值是否可寻址？ %t\n", vAFromPtr.CanAddr()) // 输出：true
    fmt.Printf("A.Str 字段是否可设置？ %t\n", vAFromPtr.Field(0).CanSet()) // 输出：true

    if vAFromPtr.Field(0).CanSet() {
        vAFromPtr.Field(0).SetString("Bye")
    }
    fmt.Printf("修改后 z 的值: %v\n", z) // 输出：修改后 z 的值: &{Bye}
}

// 接口包装结构体指针
var z interface{} = &A{Str: "Hello"}

// 获取 *A 的 reflect.Value，然后解引用得到 A 的 reflect.Value
vAFromPtr := reflect.ValueOf(z).Elem()

// 检查并修改字段
if vAFromPtr.Kind() == reflect.Struct && vAFromPtr.FieldByName("Str").CanSet() {
    vAFromPtr.FieldByName("Str").SetString("Bye from Pointer!")
}
fmt.Printf("通过指针修改后 z 的值: %v\n", z) // 输出: &{Bye from Pointer!}

var x interface{} = A{Str: "Hello"}

// 1. 从接口中取出值（类型断言）
a := x.(A)

// 2. 修改副本
a.Str = "Bye from Copy!"

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

fmt.Printf("通过复制-修改-重新赋值后 x 的值: %v\n", x) // 输出: {Bye from Copy!}

var x interface{} = A{Str: "Hello"}

// 1. 获取接口中值的类型
originalType := reflect.TypeOf(x) // originalType 是 A

// 2. 使用 reflect.New 创建一个该类型的新指针
// reflect.New(originalType) 返回 *A 的 reflect.Value
newPtrValue := reflect.New(originalType) // newPtrValue 是 reflect.Value of *A

// 3. 获取新指针指向的结构体值（现在是可寻址和可设置的）
newStructValue := newPtrValue.Elem() // newStructValue 是 reflect.Value of A (可寻址)

// 4. 将原始值复制到新创建的结构体中
// reflect.ValueOf(x) 得到原始 A{Str: "Hello"} 的 reflect.Value
newStructValue.Set(reflect.ValueOf(x))

// 5. 修改新创建的结构体字段
if newStructValue.Kind() == reflect.Struct && newStructValue.FieldByName("Str").CanSet() {
    newStructValue.FieldByName("Str").SetString("Bye from New & Set!")
}

// 6. 将修改后的新结构体值（或其指针）赋值回接口
// 注意：如果接口原来包装的是值，这里也应该赋值值
x = newStructValue.Interface()

fmt.Printf("通过 reflect.New 修改后 x 的值: %v\n", x) // 输出: {Bye from New & Set!}