使用reflect，如何设置结构体字段的值？

Question

使用 reflect 包处理结构字段时遇到了困难。特别是还没弄清楚如何设置字段值。

type t struct { fi int; fs string }
var r t = t{ 123, "jblow" }
var i64 int64 = 456

1. 获取字段 i 的名称 - 这似乎有效

   var field =reflect.TypeOf(r).Field(i).Name

2. 获取字段 i 的值作为 a) interface{}, b) int - 这似乎有效

   var iface 接口{} =reflect.ValueOf(r).Field(i).Interface()

   var i int = int(reflect.ValueOf(r).Field(i).Int())

3. 设置字段 i 的值 - 尝试一个 - 恐慌

   reflect.ValueOf(r).Field(i).SetInt( i64 )

   恐慌：reflect.Value·SetInt使用通过未导出字段获得的值

   假设它不喜欢字段名称“id”和“name”，因此重命名为“Id”和“Name”

   a）这个假设正确吗？

   b) 如果正确，认为没有必要，因为在同一个文件/包中

4. 设置字段 i 的值 - 尝试两个（字段名称大写） - 恐慌

   reflect.ValueOf(r).Field(i).SetInt(465)

   reflect.ValueOf(r).Field(i).SetInt( i64 )

   恐慌：reflect.Value·SetInt使用不可寻址的值

---

@peterSO 下面的说明是彻底且高质量的

四。这有效：

reflect.ValueOf(&r).Elem().Field(i).SetInt( i64 )

他还记录了字段名称必须可导出（以大写字母开头）

Answer 1

Go json 包从 Go 结构编组和解组 JSON。

下面是一个分步示例，它设置 struct 字段的值，同时小心避免错误。

Go reflect 包有一个 CanAddr 函数。

func (v Value) CanAddr() bool

如果值是，则 CanAddr 返回 true
地址可以通过Addr获得。
这样的值称为可寻址的。一个
值是可寻址的，如果它是
切片的元素、a 的元素
可寻址数组，一个字段
可寻址结构，或结果
取消引用指针。如果可以添加
返回 false，调用 Addr 将
恐慌。

Go reflect 包有一个 CanSet 函数，如果 true，则意味着 CanAddr 也是真。

func (v Value) CanSet() bool

如果 v 的值是 CanSet 返回 true
可以改变。 A 值可以改变
仅当它是可寻址且不可寻址时
通过使用未出口获得
结构体字段。如果 CanSet 返回
false，调用 Set 或任何
特定于类型的 setter（例如，SetBool、
SetInt64) 会出现恐慌。

我们需要确保我们可以设置 struct 字段。例如，

package main

import (
    "fmt"
    "reflect"
)

func main() {
    type t struct {
        N int
    }
    var n = t{42}
    // N at start
    fmt.Println(n.N)
    // pointer to struct - addressable
    ps := reflect.ValueOf(&n)
    // struct
    s := ps.Elem()
    if s.Kind() == reflect.Struct {
        // exported field
        f := s.FieldByName("N")
        if f.IsValid() {
            // A Value can be changed only if it is 
            // addressable and was not obtained by 
            // the use of unexported struct fields.
            if f.CanSet() {
                // change value of N
                if f.Kind() == reflect.Int {
                    x := int64(7)
                    if !f.OverflowInt(x) {
                        f.SetInt(x)
                    }
                }
            }
        }
    }
    // N at end
    fmt.Println(n.N)
}

Output:
42
7

如果我们可以确定所有错误检查都是不必要的，则该示例可简化为，

package main

import (
    "fmt"
    "reflect"
)

func main() {
    type t struct {
        N int
    }
    var n = t{42}
    fmt.Println(n.N)
    reflect.ValueOf(&n).Elem().FieldByName("N").SetInt(7)
    fmt.Println(n.N)
}

顺便说一句，Go 可用为 开源代码。了解反射的一个好方法是看看核心 Go 开发人员如何使用它。例如，Go fmt 和 json 包。包文档在包文件标题下提供了源代码文件的链接。

Answer 2

这似乎有效：

package main

import (
    "fmt"
    "reflect"
)

type Foo struct {
    Number int
    Text string
}

func main() {
    foo := Foo{123, "Hello"}

    fmt.Println(int(reflect.ValueOf(foo).Field(0).Int()))

    reflect.ValueOf(&foo).Elem().Field(0).SetInt(321)

    fmt.Println(int(reflect.ValueOf(foo).Field(0).Int()))
}

打印：

123
321

Answer 3

您可以创建一个辅助函数来设置值：

package main

import (
    "fmt"
    "log"
    "reflect"
    "time"
)

type Apple struct {
    Color     string
    CreatedAt time.Time
}

func SetValue(obj any, field string, value any) {
    ref := reflect.ValueOf(obj)

    // if its a pointer, resolve its value
    if ref.Kind() == reflect.Ptr {
        ref = reflect.Indirect(ref)
    }

    if ref.Kind() == reflect.Interface {
        ref = ref.Elem()
    }

    // should double check we now have a struct (could still be anything)
    if ref.Kind() != reflect.Struct {
        log.Fatal("unexpected type")
    }

    prop := ref.FieldByName(field)
    prop.Set(reflect.ValueOf(value))
}

func main() {
    myStruct := Apple{}
    SetValue(&myStruct, "Color", "red")
    SetValue(&myStruct, "CreatedAt", time.Now())
    fmt.Printf("Result: %+v\n", myStruct)
}

Playground： https://go.dev/play/p/ uHoy5n3k1DW