面试题：Go反射在复杂结构体嵌套数据处理中的应用

反射基础：
- 在Go中，通过reflect包来实现反射功能。首先获取结构体的reflect.Value和reflect.Type。可以使用reflect.ValueOf和reflect.TypeOf函数，例如：
```
var myStruct MyComplexStruct
value := reflect.ValueOf(myStruct)
typeInfo := reflect.TypeOf(myStruct)
```

深度遍历结构体：

使用递归方式进行深度遍历。当遇到结构体字段时，继续递归调用遍历函数。

func deepTraverse(value reflect.Value, typeInfo reflect.Type) {
    for i := 0; i < value.NumField(); i++ {
        fieldValue := value.Field(i)
        fieldType := typeInfo.Field(i).Type
        if fieldType.Kind() == reflect.Struct {
            deepTraverse(fieldValue, fieldType)
        } else if fieldType.Kind() == reflect.Slice && fieldType.Elem().Kind() == reflect.Struct {
            for j := 0; j < fieldValue.Len(); j++ {
                elem := fieldValue.Index(j)
                deepTraverse(elem, fieldType.Elem())
            }
        }
        // 这里可以加入数据验证逻辑
    }
}

数据验证：

对于数字字段，判断是否大于0。

if fieldType.Kind() == reflect.Int || fieldType.Kind() == reflect.Int8 || fieldType.Kind() == reflect.Int16 ||
    fieldType.Kind() == reflect.Int32 || fieldType.Kind() == reflect.Int64 {
    if fieldValue.Int() <= 0 {
        fmt.Printf("数字字段 %s 不大于0\n", typeInfo.Field(i).Name)
    }
}

对于字符串字段，判断长度是否符合要求。

if fieldType.Kind() == reflect.String {
    if fieldValue.Len() < minLength || fieldValue.Len() > maxLength {
        fmt.Printf("字符串字段 %s 长度不符合要求\n", typeInfo.Field(i).Name)
    }
}

性能优化：
- 减少反射调用：反射操作相对比较慢，尽量在循环外部获取反射信息，例如在递归调用前获取reflect.Type和reflect.Value，而不是在每次循环内获取。
- 缓存反射结果：如果对同一个结构体类型会多次进行反射操作，可以考虑缓存reflect.Type等信息，避免重复获取。可以使用map来缓存，以结构体类型为键，反射信息为值。
- 避免不必要的转换：在反射操作中，尽量避免不必要的类型转换，例如从reflect.Value转换为具体类型再进行操作，可以直接利用reflect.Value提供的方法进行操作。

完整示例代码如下：

package main

import (
    "fmt"
    "reflect"
)

type InnerStruct struct {
    InnerInt int
    InnerStr string
}

type MyComplexStruct struct {
    IntField   int
    StrField   string
    InnerSlice []InnerStruct
    Inner      InnerStruct
}

func deepTraverse(value reflect.Value, typeInfo reflect.Type) {
    for i := 0; i < value.NumField(); i++ {
        fieldValue := value.Field(i)
        fieldType := typeInfo.Field(i).Type
        if fieldType.Kind() == reflect.Struct {
            deepTraverse(fieldValue, fieldType)
        } else if fieldType.Kind() == reflect.Slice && fieldType.Elem().Kind() == reflect.Struct {
            for j := 0; j < fieldValue.Len(); j++ {
                elem := fieldValue.Index(j)
                deepTraverse(elem, fieldType.Elem())
            }
        }

        // 数据验证
        if fieldType.Kind() == reflect.Int || fieldType.Kind() == reflect.Int8 || fieldType.Kind() == reflect.Int16 ||
            fieldType.Kind() == reflect.Int32 || fieldType.Kind() == reflect.Int64 {
            if fieldValue.Int() <= 0 {
                fmt.Printf("数字字段 %s 不大于0\n", typeInfo.Field(i).Name)
            }
        }
        if fieldType.Kind() == reflect.String {
            minLength := 1
            maxLength := 10
            if fieldValue.Len() < minLength || fieldValue.Len() > maxLength {
                fmt.Printf("字符串字段 %s 长度不符合要求\n", typeInfo.Field(i).Name)
            }
        }
    }
}

func main() {
    myStruct := MyComplexStruct{
        IntField:   1,
        StrField:   "test",
        InnerSlice: []InnerStruct{{InnerInt: 2, InnerStr: "inner1"}, {InnerInt: 3, InnerStr: "inner2"}},
        Inner:      InnerStruct{InnerInt: 4, InnerStr: "inner"},
    }
    value := reflect.ValueOf(myStruct)
    typeInfo := reflect.TypeOf(myStruct)
    deepTraverse(value, typeInfo)
}

星途面试题库

面试题：Go反射在复杂结构体嵌套数据处理中的应用

知识考点

面试题答案