如何在 Go 反射中安全地向切片（slice）添加元素

本文详解如何使用 Go 的 reflect 包动态创建结构体切片并追加元素，重点解决 reflect.Append 在 interface{} 上 panic 的常见错误，强调必须操作可寻址的 reflect.Value 且类型需匹配。

在 Go 里通过反射操作切片时，不少人会遇到一个典型坑：直接用 reflect.Zero 创建值，然后试图用 reflect.Append 追加元素——结果直接 panic，报错“call of reflect.Append on interface Value”。根本原因在于 reflect.Zero 返回的是一个只读副本，既不能寻址也不能设置，而 reflect.Append 要求第一个参数必须是可寻址（addressable）且可设置（settable）的 slice 类型 reflect.Value。换句话说，你拿到的只是一个“快照”，无法通过 Set() 修改，自然也拼不出新的切片。

正确解法其实很直接：始终用 reflect.New() 分配可寻址的内存空间，再通过 .Elem() 拿到它的底层值。下面拆解一下关键步骤，并附上完整的可运行代码。

正确步骤解析

1. 传入指针，确保可寻址性：函数接收 interface{} 时，应该传指向目标切片的指针（比如 &[]A{} 或 &models），而不是值本身。因为只有指针才能被反射识别为可寻址。
2. 动态构造切片类型：用 reflect.SliceOf(reflect.TypeOf(v).Elem()) 构建目标结构体的切片类型，这一步相当于在运行时“拼出” []A 这样的类型。
3. 分配可修改的切片实例：调用 reflect.New(sliceType).Elem()，得到一个空但可设置的 reflect.Value。这个值就像一块空白画布，可以往里追加内容。
4. 逐个创建并追加元素：对每个新元素，用 reflect.New(elemType) 创建指针，.Elem() 后设置字段，再通过 reflect.Append 追加，并用 sl.Set(...) 更新原 slice。注意：Append 不就地修改，必须把返回值写回去。

完整可运行示例

package main

import (
    "fmt"
    "reflect"
)

type A struct {
    Name string `column:"email"`
}

func main() {
    bbb(&A{}) // 传入结构体指针，便于推导元素类型
}

func aaa(v interface{}) {
    sl := reflect.ValueOf(v)
    if !sl.IsValid() || !sl.CanAddr() || sl.Kind() != reflect.Ptr {
        panic("input must be addressable pointer to slice")
    }
    sl = sl.Elem() // 获取 slice 值本身
    if sl.Kind() != reflect.Slice {
        panic("dereferenced value is not a slice")
    }

    elemType := sl.Type().Elem()
    if elemType.Kind() == reflect.Ptr {
        elemType = elemType.Elem()
    }

    fmt.Printf("Target slice element type: %v\n", elemType)

    // 动态追加 3 个元素
    for i := 0; i < 3; i++ {
        newItemPtr := reflect.New(elemType)           // *A
        newItem := newItemPtr.Elem()                  // A（可设置）
        newItem.FieldByName("Name").SetString(fmt.Sprintf("Item-%d", i))

        sl = reflect.Append(sl, newItemPtr) // Append 返回新 Value，非就地修改
        // 必须重新赋值给 sl，并最终写回原变量
    }

    // 将更新后的 slice 写回调用方传入的指针所指向的位置
    reflect.ValueOf(v).Elem().Set(sl)
}

func bbb(v interface{}) {
    t := reflect.TypeOf(v).Elem() // 解引用得到 struct 类型 A
    if t.Kind() != reflect.Struct {
        panic("expected pointer to struct")
    }

    // 创建 []A 类型的指针：*[]A
    sliceType := reflect.SliceOf(t)
    modelsPtr := reflect.New(sliceType) // 可寻址的 *[]A

    // 调用 aaa，传入 *[]A 的 interface{}
    aaa(modelsPtr.Interface())

    // 输出结果
    result := modelsPtr.Elem().Interface()
    fmt.Printf("Final slice: %+v\n", result) // [{Name:"Item-0"} {Name:"Item-1"} {Name:"Item-2"}]
}

关键注意事项

• reflect.Append 不就地修改原 slice，而是返回一个新的 reflect.Value。你必须在每次追加后显式调用 .Set() 将其写回原变量，否则操作无效。
• 所有参与反射操作的值必须满足 CanAddr() && CanSet()——这是安全红线，一旦违反，Set 或 Append 就会直接 panic。
• 用 reflect.New() 而不是 reflect.Zero() 是保障可设置性的基本前提。前者分配了真实内存，后者只返回一个零值副本。
• 如果目标结构体字段带有 tag（如 column:"email"），可以通过 Field(i).Tag.Get("column") 提取，这个技巧在 ORM 映射或通用数据加载器中非常实用。

掌握这套模式之后，你就可以安全地构建通用数据加载器、JSON 反序列化中间件，或者动态表单处理器等需要反射驱动的组件。核心就是记住：先 New，再 Elem，然后 Append，最后 Set——一步都不能少。