使用 Go 语言 reflect 包设置结构体字段值

package main

import (
    "fmt"
    "reflect"
)

// 定义一个结构体，包含一个导出字段 N
type MyStruct struct {
    N int // N 是导出字段，可被反射设置
    s string // s 是未导出字段，不可被反射设置
}

func main() {
    // 1. 初始化一个结构体实例
    var myInstance = MyStruct{N: 42, s: "initial"}
    fmt.Printf("初始值: %+v\n", myInstance) // Output: 初始值: {N:42 s:initial}

    // 2. 获取指向结构体实例的 reflect.Value
    // 传入 &myInstance 而不是 myInstance，确保获取的是可寻址的 Value
    ptrValue := reflect.ValueOf(&myInstance)

    // 3. 使用 Elem() 获取指针指向的实际结构体 Value
    // Elem() 返回指针指向的元素，它现在是可寻址的
    structValue := ptrValue.Elem()

    // 4. 检查获取到的 Value 是否确实是结构体类型
    if structValue.Kind() == reflect.Struct {
        // 5. 通过字段名获取要修改的字段的 reflect.Value
        // 尝试获取导出字段 "N"
        fieldN := structValue.FieldByName("N")

        // 6. 检查字段是否有效 (是否存在)
        if fieldN.IsValid() {
            // 7. 关键步骤：检查字段是否可设置
            // 只有 CanSet() 为 true 的 Value 才能被修改
            if fieldN.CanSet() {
                // 8. 检查字段类型，并进行类型安全的设置
                if fieldN.Kind() == reflect.Int {
                    newValue := int64(77)
                    // 9. 额外检查：对于数值类型，检查是否会溢出
                    if !fieldN.OverflowInt(newValue) {
                        fieldN.SetInt(newValue) // 设置 int 类型字段的值
                        fmt.Printf("成功设置导出字段 N: %+v\n", myInstance) // Output: 成功设置导出字段 N: {N:77 s:initial}
                    } else {
                        fmt.Printf("设置字段 N 失败：值 %d 溢出\n", newValue)
                    }
                } else {
                    fmt.Printf("字段 N 类型不匹配，期望 int，实际是 %s\n", fieldN.Kind())
                }
            } else {
                fmt.Println("字段 N 不可设置 (可能未导出或不可寻址)。")
            }
        } else {
            fmt.Println("字段 N 不存在。")
        }

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

        // 尝试修改未导出字段 "s"
        fieldS := structValue.FieldByName("s")
        if fieldS.IsValid() {
            if fieldS.CanSet() {
                // 这段代码不会执行，因为 fieldS.CanSet() 会是 false
                if fieldS.Kind() == reflect.String {
                    fieldS.SetString("new value")
                    fmt.Printf("成功设置未导出字段 s: %+v\n", myInstance)
                }
            } else {
                fmt.Println("字段 s 不可设置 (未导出字段)。") // Output: 字段 s 不可设置 (未导出字段)。
            }
        } else {
            fmt.Println("字段 s 不存在。")
        }

    } else {
        fmt.Println("传入的不是结构体类型。")
    }

    fmt.Printf("最终值: %+v\n", myInstance) // Output: 最终值: {N:77 s:initial}
}

package main

import (
    "fmt"
    "reflect"
)

type SimplifiedStruct struct {
    Value int
}

func main() {
    var s = SimplifiedStruct{Value: 100}
    fmt.Printf("初始值: %+v\n", s) // Output: 初始值: {Value:100}

    // 简洁的设置方式：直接链式调用
    reflect.ValueOf(&s).Elem().FieldByName("Value").SetInt(200)

    fmt.Printf("最终值: %+v\n", s) // Output: 最终值: {Value:200}
}