使用 Go 反射动态创建指定类型的切片

package main

import (
    "fmt"
    "reflect"
)

type My struct {
    Name string
    Id   int
}

func main() {
    myInstance := &My{}
    myType := reflect.TypeOf(myInstance) // myType 是 *main.My

    // 错误示例：以下代码无法编译
    // a := make([](myType.(type)), 0)
    // fmt.Println(a)
}

package main

import (
    "fmt"
    "reflect"
)

type My struct {
    Name string
    Id   int
}

func main() {
    // 假设我们有一个 My 结构体的指针，并希望创建 []My 类型的切片
    myPtr := &My{}
    ptrType := reflect.TypeOf(myPtr) // ptrType 是 *main.My

    // 通常我们希望创建的是 []My，而不是 []*My。
    // 因此，需要获取指针指向的元素类型 My。
    // 如果直接从 My{} 开始，则 elementType = reflect.TypeOf(My{})
    elementType := ptrType.Elem() // elementType 是 main.My
    fmt.Printf("目标元素类型: %v (种类: %v)\n", elementType, elementType.Kind())

    // 1. 使用 reflect.SliceOf 获取切片类型（例如，从 My 获取 []My 的类型）
    sliceType := reflect.SliceOf(elementType)
    fmt.Printf("构建的切片类型: %v (种类: %v)\n", sliceType, sliceType.Kind())

    // 2. 使用 reflect.MakeSlice 创建一个长度为0，容量为0的切片值
    // dynamicSliceValue 是一个 reflect.Value，它封装了一个 []My 类型的切片
    dynamicSliceValue := reflect.MakeSlice(sliceType, 0, 0)

    // 3. 将 reflect.Value 转换为实际的 Go 接口值
    dynamicSlice := dynamicSliceValue.Interface()

    fmt.Printf("使用 MakeSlice 创建的动态切片: %v, 类型: %T\n", dynamicSlice, dynamicSlice)

    // 如果需要将这个动态创建的切片用于具体操作，通常需要进行类型断言
    if concreteSlice, ok := dynamicSlice.([]My); ok {
        fmt.Printf("类型断言成功，具体切片: %v\n", concreteSlice)

        // 示例：使用 reflect.Append 向切片中添加元素
        // 注意：reflect.Append 返回一个新的 reflect.Value，需要重新赋值
        newElement := reflect.ValueOf(My{Name: "TestUser", Id: 101})
        dynamicSliceValue = reflect.Append(dynamicSliceValue, newElement)
        fmt.Printf("添加元素后的切片: %v, 类型: %T\n", dynamicSliceValue.Interface(), dynamicSliceValue.Interface())
    }
}

package main

import (
    "fmt"
    "reflect"
)

type My struct {
    Name string
    Id   int
}

func main() {
    myPtr := &My{}
    ptrType := reflect.TypeOf(myPtr)
    elementType := ptrType.Elem() // 目标元素类型 My

    // 1. 获取切片类型 (例如，[]My 的 reflect.Type)
    sliceType := reflect.SliceOf(elementType)

    // 2. 使用 reflect.Zero 创建一个 nil 切片值
    nilSliceValue := reflect.Zero(sliceType)

    // 3. 将 reflect.Value 转换为实际的 Go 接口值
    nilSlice := nilSliceValue.Interface()

    fmt.Printf("使用 Zero 创建的 nil 切片: %v, 类型: %T\n", nilSlice, nilSlice)

    // 检查 reflect.Value 是否为 nil
    fmt.Printf("reflect.Value 是否代表 nil: %v\n", nilSliceValue.IsNil())

    // 检查 Interface() 返回的切片是否为 nil
    if concreteNilSlice, ok := nilSlice.([]My); ok {
        fmt.Printf("类型断言成功，具体 nil 切片: %v\n", concreteNilSlice)
        fmt.Printf("具体 nil 切片是否为 nil: %v\n", concreteNilSlice == nil) // 这将输出 true
    }

    // 对比一个显式声明的 nil 切片
    var explicitNilSlice []My = nil
    fmt.Printf("\n显式声明的 nil 切片: %v, 类型: %T, 是否为 nil: %v\n",
        explicitNilSlice, explicitNilSlice, explicitNilSlice == nil)
}