Golang如何无需传结构体指针，通过reflect处理interface{}中的nil切片转空切片？

核心结论 #

在Go的传值语义下，若要修改原结构体的字段值，必须传递结构体指针。非指针的结构体实例传入函数后，你只能修改其副本，原数据不会受到任何影响，中间件处理后序列化的依然是未修改的原数据，无法达到需求。

另外，直接修改非指针interface{}中的字段值是不可行的：reflect.ValueOf()获取非指针值的Value对象时，CanSet()会返回false，因为该值不可寻址，反射包不允许修改这类值。

对尝试方案的补充说明 #

1. JSON序列化转map的问题：JSON序列化时会把nil切片转为null，反序列化为map[string]interface{}后，无法区分原字段是nil切片还是其他类型的null值，同时丢失了原字段的类型信息，确实无法完成精准替换。
2. 直接处理非指针interface{}的问题：非指针的结构体值属于不可寻址对象，反射包无法修改其字段；如果传入的不是结构体类型（比如直接传切片），调用NumField()必然触发panic，这是反射操作的类型约束导致的。
3. 传指针可行但需约束：虽然传指针是唯一可行的方案，但可以通过函数内部的类型检查来降低错误概率，避免无意义的panic。

优化后的可行实现 #

下面是一个递归处理指针类型的工具函数，能自动将嵌套结构体、切片中的nil切片替换为空切片，同时加入参数检查避免错误：

import (
    "fmt"
    "reflect"
)

// FixNilSlices 接收结构体/切片的指针，将其中所有nil切片替换为空切片
func FixNilSlices(data interface{}) error {
    v := reflect.ValueOf(data)
    // 检查输入是否为非nil指针，且指向可修改的值
    if v.Kind() != reflect.Ptr || v.IsNil() || !v.Elem().CanSet() {
        return fmt.Errorf("参数必须是非nil的结构体或切片指针")
    }
    fixNilSlicesRecursive(v.Elem())
    return nil
}

// fixNilSlicesRecursive 递归处理reflect.Value，替换nil切片
func fixNilSlicesRecursive(v reflect.Value) {
    switch v.Kind() {
    case reflect.Struct:
        // 遍历结构体的导出字段（首字母大写）
        for i := 0; i < v.NumField(); i++ {
            field := v.Field(i)
            if field.CanSet() {
                fixNilSlicesRecursive(field)
            }
        }
    case reflect.Slice:
        // 替换nil切片为空切片
        if v.IsNil() {
            emptySlice := reflect.MakeSlice(v.Type(), 0, 0)
            v.Set(emptySlice)
        } else {
            // 遍历切片元素，处理嵌套结构
            for i := 0; i < v.Len(); i++ {
                elem := v.Index(i)
                if elem.Kind() == reflect.Ptr {
                    if !elem.IsNil() {
                        fixNilSlicesRecursive(elem.Elem())
                    }
                } else {
                    fixNilSlicesRecursive(elem)
                }
            }
        }
    case reflect.Ptr:
        // 处理非nil指针指向的内容
        if !v.IsNil() {
            fixNilSlicesRecursive(v.Elem())
        }
    // 其他类型（如基本类型、map等）无需处理
    }
}

使用示例 #

type SubModel struct {
    Tags []string
}

type MainModel struct {
    ID    int
    Items []int
    Sub   SubModel
}

func main() {
    model := MainModel{
        ID: 1,
        // Items是nil切片
        Sub: SubModel{
            // Tags是nil切片
        },
    }

    // 传入指针
    if err := FixNilSlices(&model); err != nil {
        panic(err)
    }

    // 此时model.Items和model.Sub.Tags都会被转为空切片
    // 后续序列化JSON时会输出[]而非null
}

为什么不能避免传指针？ #

Go语言的函数参数传递是值传递：如果你传入结构体实例，函数内部会创建一个完全独立的副本。即使你修改副本的字段，原结构体实例的字段值不会有任何变化。中间件的核心需求是修改即将序列化的原数据，因此必须传递指针，让函数能直接操作原数据的内存地址。

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