Go 语言中利用 reflect 包动态创建指定类型切片

package main

import (
    "fmt"
    "reflect"
)

type My struct {
    Name string
    Id   int
}

func main() {
    // 获取My结构体的reflect.Type
    // 注意：如果从一个指针实例(&My{})开始，需要使用.Elem()来获取实际的结构体类型
    myType := reflect.TypeOf(My{}) // 获取 My 类型的 reflect.Type
    fmt.Printf("元素类型: %v, Kind: %s\n", myType, myType.Kind())

    // 使用 reflect.SliceOf 获取 []My 的 reflect.Type
    sliceType := reflect.SliceOf(myType)
    fmt.Printf("切片类型: %v, Kind: %s\n", sliceType, sliceType.Kind())
}

package main

import (
    "fmt"
    "reflect"
)

type My struct {
    Name string
    Id   int
}

func main() {
    // 1. 获取目标元素类型 (例如 My)
    // 如果原始类型是 *My，并且你希望创建 []*My，则 myType 保持为 reflect.TypeOf(&My{}).Elem()
    // 如果你希望创建 []My，则 myType 应该为 reflect.TypeOf(My{})
    myType := reflect.TypeOf(My{}) // 获取 My 结构体的 reflect.Type

    fmt.Printf("目标元素类型: %v\n", myType)

    // 2. 使用 reflect.SliceOf 获取 []My 的 reflect.Type
    sliceOfType := reflect.SliceOf(myType)
    fmt.Printf("目标切片类型: %v\n", sliceOfType)

    // 3. 使用 reflect.MakeSlice 动态创建切片，初始长度和容量均为 0
    // MakeSlice 返回一个 reflect.Value，表示新创建的切片
    sliceValue := reflect.MakeSlice(sliceOfType, 0, 0)

    // 4. 将 reflect.Value 转换为 Go 接口类型，以便后续操作
    // 此时 slice 变量的实际类型是 []My
    slice := sliceValue.Interface()

    fmt.Printf("创建的切片类型: %T, 值: %v\n", slice, slice)
    fmt.Printf("切片长度: %d, 容量: %d\n", reflect.ValueOf(slice).Len(), reflect.ValueOf(slice).Cap())

    // 示例：向动态创建的切片中添加元素
    // 注意：直接对 slice 进行 append 操作是不允许的，需要通过 reflect.Append
    newElemValue := reflect.New(myType).Elem() // 创建一个 My 类型的零值 reflect.Value
    newElemValue.FieldByName("Name").SetString("Dynamic Item")
    newElemValue.FieldByName("Id").SetInt(123)

    sliceValue = reflect.Append(sliceValue, newElemValue) // 使用 reflect.Append 添加元素
    slice = sliceValue.Interface() // 更新 slice 变量以反映变化

    fmt.Printf("添加元素后的切片类型: %T, 值: %v\n", slice, slice)
    fmt.Printf("添加元素后切片长度: %d, 容量: %d\n", reflect.ValueOf(slice).Len(), reflect.ValueOf(slice).Cap())
}

package main

import (
    "fmt"
    "reflect"
)

type My struct {
    Name string
    Id   int
}

func main() {
    myType := reflect.TypeOf(My{})
    sliceOfType := reflect.SliceOf(myType)

    // 使用 reflect.Zero 创建一个零值切片 (对于切片类型，这将是一个 nil 切片)
    nilSliceValue := reflect.Zero(sliceOfType)
    nilSlice := nilSliceValue.Interface()

    fmt.Printf("创建的nil切片类型: %T, 值: %v\n", nilSlice, nilSlice)
    fmt.Printf("nil切片是否为nil: %t\n", reflect.ValueOf(nilSlice).IsNil())
    fmt.Printf("nil切片长度: %d, 容量: %d\n", reflect.ValueOf(nilSlice).Len(), reflect.ValueOf(nilSlice).Cap())

    // 对比 MakeSlice(..., 0, 0) 和 Zero 的区别
    // MakeSlice(..., 0, 0) 会创建一个非 nil 的空切片
    emptySliceValue := reflect.MakeSlice(sliceOfType, 0, 0)
    emptySlice := emptySliceValue.Interface()
    fmt.Printf("MakeSlice创建的空切片是否为nil: %t\n", reflect.ValueOf(emptySlice).IsNil())
}