Go语言反射：获取切片元素类型与动态数据填充实践

package main

import (
    "fmt"
    "reflect"
)

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

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

    // 同样适用于指针类型
    ptrType := reflect.TypeOf(&struct{}{})
    fmt.Printf("指针类型: %v, Kind: %v\n", ptrType, ptrType.Kind()) // 输出: 指针类型: *struct {}, Kind: ptr
    ptrElemType := ptrType.Elem()
    fmt.Printf("指针指向的类型: %v, Kind: %v\n", ptrElemType, ptrElemType.Kind()) // 输出: 指针指向的类型: struct {}, Kind: struct
}

package main

import (
    "fmt"
    "reflect"
    "strconv"
)

// populateSliceFromStrings 动态填充切片
// targetSliceType: 目标切片的 reflect.Type (例如 reflect.TypeOf([]int{}))
// stringValues: 待填充的字符串数组
// 返回填充后的 reflect.Value，如果失败则返回零值和错误
func populateSliceFromStrings(targetSliceType reflect.Type, stringValues []string) (reflect.Value, error) {
    if targetSliceType.Kind() != reflect.Slice {
        return reflect.Value{}, fmt.Errorf("目标类型 %v 不是切片类型", targetSliceType)
    }

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

    // 2. 创建一个指定长度和容量的切片
    numElems := len(stringValues)
    sliceValue := reflect.MakeSlice(targetSliceType, numElems, numElems)

    // 3. 遍历字符串数组，并填充切片
    for i, strVal := range stringValues {
        // 4. 创建一个可编辑的 reflect.Value 来存储转换后的元素
        // reflect.New(elementType).Elem() 创建一个 elementType 类型的零值，并返回其可编辑的 Value
        elemValue := reflect.New(elementType).Elem()

        // 5. 根据元素类型进行类型转换和赋值
        switch elementType.Kind() {
        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
            parsedInt, err := strconv.ParseInt(strVal, 10, elementType.Bits())
            if err != nil {
                return reflect.Value{}, fmt.Errorf("无法将 '%s' 转换为 %v 类型: %v", strVal, elementType, err)
            }
            elemValue.SetInt(parsedInt)
        case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
            parsedUint, err := strconv.ParseUint(strVal, 10, elementType.Bits())
            if err != nil {
                return reflect.Value{}, fmt.Errorf("无法将 '%s' 转换为 %v 类型: %v", strVal, elementType, err)
            }
            elemValue.SetUint(parsedUint)
        case reflect.Float32, reflect.Float64:
            parsedFloat, err := strconv.ParseFloat(strVal, elementType.Bits())
            if err != nil {
                return reflect.Value{}, fmt.Errorf("无法将 '%s' 转换为 %v 类型: %v", strVal, elementType, err)
            }
            elemValue.SetFloat(parsedFloat)
        case reflect.Bool:
            parsedBool, err := strconv.ParseBool(strVal)
            if err != nil {
                return reflect.Value{}, fmt.Errorf("无法将 '%s' 转换为 %v 类型: %v", strVal, elementType, err)
            }
            elemValue.SetBool(parsedBool)
        case reflect.String:
            elemValue.SetString(strVal)
        default:
            return reflect.Value{}, fmt.Errorf("不支持的元素类型: %v", elementType)
        }

        // 6. 将转换后的元素值设置到切片的对应位置
        sliceValue.Index(i).Set(elemValue)
    }

    return sliceValue, nil
}

func main() {
    inputStrings := []string{"10", "20", "30", "40"}

    // 示例1: 填充 []int
    intSliceType := reflect.TypeOf([]int{})
    intSliceVal, err := populateSliceFromStrings(intSliceType, inputStrings)
    if err != nil {
        fmt.Println("填充 []int 失败:", err)
    } else {
        fmt.Printf("填充后的 []int 切片: %v, 类型: %v\n", intSliceVal.Interface(), intSliceVal.Type())
        // 验证类型和值
        if _, ok := intSliceVal.Interface().([]int); ok {
            fmt.Println("类型验证成功: []int")
        }
    }
    fmt.Println("---")

    // 示例2: 填充 []float64
    floatSliceType := reflect.TypeOf([]float64{})
    floatInputStrings := []string{"1.1", "2.2", "3.3"}
    floatSliceVal, err := populateSliceFromStrings(floatSliceType, floatInputStrings)
    if err != nil {
        fmt.Println("填充 []float64 失败:", err)
    } else {
        fmt.Printf("填充后的 []float64 切片: %v, 类型: %v\n", floatSliceVal.Interface(), floatSliceVal.Type())
    }
    fmt.Println("---")

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

    // 示例4: 填充 []string (直接赋值)
    stringSliceType := reflect.TypeOf([]string{})
    stringInputStrings := []string{"hello", "world", "Go"}
    stringSliceVal, err := populateSliceFromStrings(stringSliceType, stringInputStrings)
    if err != nil {
        fmt.Println("填充 []string 失败:", err)
    } else {
        fmt.Printf("填充后的 []string 切片: %v, 类型: %v\n", stringSliceVal.Interface(), stringSliceVal.Type())
    }
    fmt.Println("---")

    // 示例5: 错误情况 - 无效的类型转换
    invalidIntInputStrings := []string{"1", "abc", "3"}
    _, err = populateSliceFromStrings(intSliceType, invalidIntInputStrings)
    if err != nil {
        fmt.Println("填充 []int 失败 (预期错误):", err)
    }
}