使用反射读取嵌套结构

Question

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

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
} 

Answer 1

您的代码中有几个错误。

首先，如果传递的值是指针，则只需调用

Value.Elem()

。当您迭代字段并找到结构体类型的字段时，您可以递归地调用

ReadStruct()

，它不会是指针，因此您不能对其调用

Elem()

。

所以这样做：

val := reflect.ValueOf(st)
if val.Kind() == reflect.Ptr {
    val = val.Elem()
}

接下来，由于您通过调用

ReadStruct()

 来启动 

reflect.ValueOf()，因此假设您必须将非反射值传递给

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.Value

会更高效，这样您就可以避免这些不必要的调用。

您可以这样做：

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 上尝试一下这个。

Answer 2

很棒的解释！！

我们可以直接使用reflect.Indirect()

val = reflect.Indirect(val)

而不是

if val.Kind() == reflect.Ptr {
    val = val.Elem()
}