利用反射遍历嵌套结构

从现在开始，努力学习吧！本文《利用反射遍历嵌套结构》主要讲解了等等相关知识点，我会在golang学习网中持续更新相关的系列文章，欢迎大家关注并积极留言建议。下面就先一起来看一下本篇正文内容吧，希望能帮到你！

我编写了一个递归函数，它迭代深层嵌套结构，如下所示：

type container struct {
    name string
    items []item
}

type item struct {
    name string
    info info
    vals []string
}
// recursively reads nested struct, prints string values
func readstruct(st interface{}) {
    val := reflect.valueof(st).elem()
    for i := 0; i < val.numfield(); i++ {
        fmt.println(val.type().field(i).type.kind())
        switch val.type().field(i).type.kind() {
        case reflect.struct:
            readstruct(val.field(i)) // panic: call of reflect.value.elem on struct value
        case reflect.slice:
            // how to iterate over the reflect.slice? 
        case reflect.string:
            fmt.printf("%v=%v", val.type().field(i).name, val.field(i))
        }
    }

如何使用反射访问内部对象（切片、结构）以使用它们？ 为了迭代切片，我尝试使用：

for i:= 0; i < val.Field(i).Slice(0, val.Field(i).Len()); i++ { //error: reflect.Value doesnt support indexing
//some work
}

正确答案

您的代码中有几个错误。

首先，如果传递的值是指针，则只需调用 Value.Elem()。当您迭代字段并找到结构类型的字段时，并用它递归调用 readstruct() 时，它不会是指针，因此您不能对其调用 elem() 。

所以这样做：

val := reflect.valueof(st)
if val.kind() == reflect.ptr {
    val = val.elem()
}

接下来，由于您通过调用 reflect.ValueOf() 启动 readstruct()，因此假设您必须将非反射值传递给 readstruct() （即，不是 reflect.Value 类型的值）。

但是当您迭代字段并调用 Value.Field() 时，您会得到一个包装该字段的 reflect.value 。您必须调用 Value.Interface() 从其中提取非反射值，以便在递归调用中传递。

要迭代切片，只需使用 Value.Len() 获取切片长度，并使用 Value.Index() 获取切片的第 i^th 元素。

这是遍历函数的更正版本：

// i used this type as you didn't post it in your question.
type info struct {
    key, value string
}

func readstruct(st interface{}) {
    val := reflect.valueof(st)
    if val.kind() == reflect.ptr {
        val = val.elem()
    }
    for i := 0; i < val.numfield(); i++ {
        // fmt.println(val.type().field(i).type.kind())
        f := val.field(i)
        switch f.kind() {
        case reflect.struct:
            readstruct(f.interface())
        case reflect.slice:
            for j := 0; j < f.len(); j++ {
                readstruct(f.index(i).interface())
            }
        case reflect.string:
            fmt.printf("%v=%v\n", val.type().field(i).name, val.field(i).interface())
        }
    }
}

测试它：

c := &container{
    name: "c1",
    items: []item{
        {
            name: "i1",
            info: info{key: "k1", value: "v1"},
        },
        {
            name: "i2",
            info: info{key: "k2", value: "v2"},
        },
    },
}
readstruct(c)

输出（在Go Playground上尝试一下）：

name=c1
name=i2
key=k2
value=v2
name=i2
key=k2
value=v2

注意：通过使用递归调用，您将提取并重新获取 reflect.value 值。始终使用 reflect.values 会更高效，因此您可以避免这些不必要的调用。

您可以这样做：

func ReadStruct(st interface{}) {
    readStruct(reflect.ValueOf(st))
}

func readStruct(val reflect.Value) {
    if val.Kind() == reflect.Ptr {
        val = val.Elem()
    }
    for i := 0; i < val.NumField(); i++ {
        // fmt.Println(val.Type().Field(i).Type.Kind())
        f := val.Field(i)
        switch f.Kind() {
        case reflect.Struct:
            readStruct(f)
        case reflect.Slice:
            for j := 0; j < f.Len(); j++ {
                readStruct(f.Index(i))
            }
        case reflect.String:
            fmt.Printf("%v=%v\n", val.Type().Field(i).Name, val.Field(i))
        }
    }
}

这将输出相同的结果。在 Go Playground 上试试这个。

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于Golang的相关知识，也可关注golang学习网公众号。