利用反射，可以对数据结构进行迭代：类型断言：转换为具体类型，获取元素。反射：获取值、键，访问值并转换为接口值。实战案例：迭代 json 对象，打印键值。

如何使用 Golang 中的反射对数据结构进行迭代

简介

反射是 Golang 中一种强大的机制，它允许程序在运行时检查和修改类型信息。利用反射，我们可以迭代各种数据结构中的元素，无论它们是已知类型还是未知类型。

立即学习“go语言免费学习笔记（深入）”；

类型断言

最简单的迭代方法是使用类型断言。这涉及将一个接口值转换为一个具体类型。

type MyType struct {
    Name string
    Age  int
}

func main() {
    var i interface{} = MyType{"Alice", 25}
    myType, ok := i.(MyType)
    if ok {
        fmt.Println(myType.Name, myType.Age)
    }
}

反射

Golang Uber Dig

使用 uber-go/dig 在 Golang 中实现依赖注入——基于反射容器，提供 Provide/Invoke、dig.In/dig.Out 参数与结果对象，支持命名依赖等

下载

如果我们无法预先知道数据结构的类型，则需要使用反射。反射提供的 reflect 包提供了用于检查和修改类型的工具。

以下是如何使用反射迭代切片：

func main() {
    s := []int{1, 2, 3}

    v := reflect.ValueOf(s)
    for i := 0; i < v.Len(); i++ {
        fmt.Println(v.Index(i).Interface())
    }
}

对于映射，我们可以使用 MapKeys 方法获取键，然后使用 MapIndex 方法访问值：

func main() {
    m := map[string]int{"Alice": 25, "Bob": 30}

    v := reflect.ValueOf(m)
    keys := v.MapKeys()
    for _, key := range keys {
        value := v.MapIndex(key)
        fmt.Println(key.String(), value.Interface())
    }
}

对于结构体，我们可以使用 NumField 方法获取字段数，然后使用 Field 方法获取字段值并使用 Interface 方法将其转换为接口值：

func main() {
    type MyType struct {
        Name string
        Age  int
    }

    myType := MyType{"Alice", 25}

    v := reflect.ValueOf(myType)
    for i := 0; i < v.NumField(); i++ {
        field := v.Field(i)
        fmt.Println(field.String(), field.Interface())
    }
}

实战案例

在以下实战案例中，我们将使用反射迭代一个 JSON 对象并打印其键和值：

{
  "name": "Alice",
  "age": 25,
  "hobbies": ["reading", "writing"]
}

func main() {
    jsonStr := `{
  "name": "Alice",
  "age": 25,
  "hobbies": ["reading", "writing"]
}`
    jsonBytes := []byte(jsonStr)

    var data interface{}
    if err := json.Unmarshal(jsonBytes, &data); err != nil {
        log.Fatal(err)
    }

    v := reflect.ValueOf(data)
    for _, key := range v.MapKeys() {
        value := v.MapIndex(key)
        fmt.Println(key.String(), value.Interface())
    }
}

结论

反射提供了在 Golang 中迭代不同数据结构的强大而灵活的方法。通过理解类型断言和反射的概念，可以编写强大的代码来处理未知和动态数据。