Go语言中如何使用反射获取切片的元素类型

package main

import (
    "fmt"
    "reflect"
)

func main() {
    // 1. 获取 []int 的 reflect.Type
    sliceType := reflect.TypeOf([]int{})
    fmt.Printf("原始切片类型: %v, Kind: %s\n", sliceType, sliceType.Kind()) // 输出: 原始切片类型: []int, Kind: Slice

    // 2. 使用 Elem() 方法获取元素类型
    elementType := sliceType.Elem()
    fmt.Printf("切片元素类型: %v, Kind: %s\n", elementType, elementType.Kind()) // 输出: 切片元素类型: int, Kind: Int

    // 3. 验证对于非切片类型调用 Elem() 的行为
    intType := reflect.TypeOf(0)
    fmt.Printf("非切片类型: %v, Kind: %s\n", intType, intType.Kind()) // 输出: 非切片类型: int, Kind: Int
    // fmt.Printf("非切片类型的元素类型: %v\n", intType.Elem()) // 此行代码会导致 panic，因为 int 不是切片、数组、指针、映射或通道
    // 在实际应用中，应先检查 Kind() 是否为 Slice、Array、Ptr、Map 或 Chan
}

package main

import (
    "fmt"
    "reflect"
    "strconv" // 用于字符串到基本类型的转换
)

// populateSliceDynamically 演示如何使用反射动态填充切片
// targetSliceType: 目标切片的 reflect.Type (例如 reflect.TypeOf([]int{}))
// stringValues: 待填充的字符串数据
func populateSliceDynamically(targetSliceType reflect.Type, stringValues []string) (reflect.Value, error) {
    // 确保目标类型是切片
    if targetSliceType.Kind() != reflect.Slice {
        return reflect.Value{}, fmt.Errorf("目标类型 %v 不是切片类型", targetSliceType)
    }

    // 获取切片的元素类型
    elementType := targetSliceType.Elem()
    numElems := len(stringValues)

    // 创建一个指定类型和容量的切片实例
    newSlice := reflect.MakeSlice(targetSliceType, numElems, numElems)

    for i, strVal := range stringValues {
        // 创建一个可设置的元素值。reflect.New返回一个指针，Elem()获取实际值。
        elemValue := reflect.New(elementType).Elem()

        // 根据元素类型进行类型转换和赋值
        switch elementType.Kind() {
        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
            intVal, err := strconv.ParseInt(strVal, 10, 64)
            if err != nil {
                return reflect.Value{}, fmt.Errorf("无法将 '%s' 转换为 %s: %w", strVal, elementType.Kind(), err)
            }
            elemValue.SetInt(intVal)
        case reflect.String:
            elemValue.SetString(strVal)
        case reflect.Bool:
            boolVal, err := strconv.ParseBool(strVal)
            if err != nil {
                return reflect.Value{}, fmt.Errorf("无法将 '%s' 转换为 %s: %w", strVal, elementType.Kind(), err)
            }
            elemValue.SetBool(boolVal)
        case reflect.Float32, reflect.Float64:
            floatVal, err := strconv.ParseFloat(strVal, 64)
            if err != nil {
                return reflect.Value{}, fmt.Errorf("无法将 '%s' 转换为 %s: %w", strVal, elementType.Kind(), err)
            }
            elemValue.SetFloat(floatVal)
        // 可以根据需要添加更多类型处理，例如 struct、complex 等
        default:
            return reflect.Value{}, fmt.Errorf("不支持的元素类型进行字符串转换: %s", elementType.Kind())
        }

        // 将处理后的元素值设置到新切片中的对应位置
        newSlice.Index(i).Set(elemValue)
    }

    return newSlice, nil
}

func main() {
    // 示例1: 填充 []int
    intSliceType := reflect.TypeOf([]int{})
    stringDataInt := []string{"10", "20", "30", "40"}
    populatedIntSlice, err := populateSliceDynamically(intSliceType, stringDataInt)
    if err != nil {
        fmt.Println("填充 []int 失败:", err)
    } else {
        // 使用 .Interface() 将 reflect.Value 转换为实际的 Go 接口值
        fmt.Printf("填充后的 []int 切片: %v (类型: %s)\n", populatedIntSlice.Interface(), populatedIntSlice.Type())
    }

    fmt.Println("--------------------")

    // 示例2: 填充 []string
    stringSliceType := reflect.TypeOf([]string{})
    stringDataStr := []string{"hello", "world", "go", "reflection"}
    populatedStringSlice, err := populateSliceDynamically(stringSliceType, stringDataStr)
    if err != nil {
        fmt.Println("填充 []string 失败:", err)
    } else {
        fmt.Printf("填充后的 []string 切片: %v (类型: %s)\n", populatedStringSlice.Interface(), populatedStringSlice.Type())
    }

    fmt.Println("--------------------")

    // 示例3: 填充 []bool
    boolSliceType := reflect.TypeOf([]bool{})
    stringDataBool := []string{"true", "false", "TRUE", "false"}
    populatedBoolSlice, err := populateSliceDynamically(boolSliceType, stringDataBool)
    if err != nil {
        fmt.Println("填充 []bool 失败:", err)
    } else {
        fmt.Printf("填充后的 []bool 切片: %v (类型: %s)\n", populatedBoolSlice.Interface(), populatedBoolSlice.Type())
    }

    fmt.Println("--------------------")

    // 示例4: 尝试填充不支持的类型 (例如 []struct{})
    type MyStruct struct{ Name string }
    structSliceType := reflect.TypeOf([]MyStruct{})
    stringDataStruct := []string{"{Name:\"A\"}", "{Name:\"B\"}"}
    _, err = populateSliceDynamically(structSliceType, stringDataStruct)
    if err != nil {
        fmt.Println("填充 []MyStruct 失败 (预期错误):", err)
    }
}