递归遍历结构体触发reflect: Field of non-struct type panic问题排查

嘿，我之前写反射递归处理结构体的时候也踩过一模一样的坑！这个panic的根源很明确：你在调用vf.Type().Field(i)的时候，vf对应的类型根本不是结构体——可能是指针、切片、字符串或者其他非结构体类型，这时候硬调用Field()方法肯定会炸。

递归处理结构体这种嵌套结构时，必须先对当前反射值的类型做判断，分情况处理不同的Kind，不能上来就直接取结构体字段。下面是完整的修正思路和代码：

核心修正点 #

• 先搞定指针类型：要修改字段的话，反射值必须是可设置的（CanSet()返回true），所以得先解引用指针，直到拿到非指针的实际值。
• 分类型递归处理：
  • 结构体类型：安全遍历字段，读取tag，递归处理嵌套字段
  • 切片/数组类型：遍历每个元素，递归处理里面的结构体
  • 字符串类型：检查tag符合条件就修改值
  • 其他类型：直接跳过（根据你的需求调整）

修正后的完整代码 #

import "reflect"

func Sanitize(s interface{}) error {
    v := reflect.ValueOf(s)
    // 处理指针：解引用到实际值，空指针直接返回
    if v.Kind() == reflect.Ptr {
        if v.IsNil() {
            return nil
        }
        v = v.Elem()
    }

    // 只有可设置的值才能修改，不可设置的直接跳过
    if !v.CanSet() {
        return nil
    }

    switch v.Kind() {
    case reflect.Struct:
        // 只有结构体类型才敢遍历字段，彻底避免panic
        for i := 0; i < v.NumField(); i++ {
            fieldVal := v.Field(i)
            fieldType := v.Type().Field(i) // 这里绝对安全，因为v是结构体类型

            // 递归处理字段的嵌套结构，传指针保证可修改
            if err := Sanitize(fieldVal.Addr().Interface()); err != nil {
                return err
            }

            // 检查是否是字符串类型且带有目标tag（比如`sanitize:"clean"`）
            if fieldVal.Kind() == reflect.String && fieldType.Tag.Get("sanitize") == "clean" {
                // 替换成你的字符串修改逻辑，比如去除敏感内容
                original := fieldVal.String()
                modified := cleanString(original)
                fieldVal.SetString(modified)
            }
        }
    case reflect.Slice, reflect.Array:
        // 遍历切片/数组的每个元素，递归处理
        for i := 0; i < v.Len(); i++ {
            elem := v.Index(i)
            // 处理元素是指针的情况
            if elem.Kind() == reflect.Ptr {
                if elem.IsNil() {
                    continue
                }
                elem = elem.Elem()
            }
            if elem.CanSet() {
                if err := Sanitize(elem.Addr().Interface()); err != nil {
                    return err
                }
            }
        }
    // 其他类型（int、bool、map等）按需处理，这里暂时跳过
    default:
        return nil
    }

    return nil
}

// 示例：你的字符串处理逻辑
func cleanString(s string) string {
    // 比如去除多余空格、替换敏感词等
    return s
}

关键细节解释 #

1. 指针与可设置性：递归时必须传字段的指针（fieldVal.Addr().Interface()），因为只有指针指向的值才能被SetString()修改，CanSet()才会返回true。
2. 类型判断前置：在处理结构体字段之前，先通过v.Kind() == reflect.Struct做判断，这样就不会在非结构体类型上调用NumField()和Field(i)，从根源杜绝了那个panic。
3. Tag读取的安全性：只有当v是结构体类型时，v.Type().Field(i)才是合法的，这时候才能正确读取字段的tag信息，完全符合反射包的使用规则。

这样修改后，你的函数就能正确处理嵌套结构体、切片里的结构体实例，而且再也不会触发那个烦人的panic了！

内容的提问来源于stack exchange，提问作者Lansana Camara