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

package main

import (
    "fmt"
    "reflect"
)

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

    // 使用 Elem() 方法获取切片元素的类型
    elemIntType := sliceIntType.Elem()
    fmt.Printf("[]int 的元素类型是: %v, Kind: %v\n", elemIntType, elemIntType.Kind()) // 输出: []int 的元素类型是: int, Kind: int

    // 示例：获取 []string 的元素类型
    sliceStringType := reflect.TypeOf([]string{})
    elemStringType := sliceStringType.Elem()
    fmt.Printf("[]string 的元素类型是: %v, Kind: %v\n", elemStringType, elemStringType.Kind()) // 输出: []string 的元素类型是: string, Kind: string

    // 注意：如果不是切片、数组或指针类型，Elem() 会发生panic或者返回无效类型
    // nonSliceType := reflect.TypeOf(123)
    // fmt.Println(nonSliceType.Elem()) // panic: Elem of non-slice/array/ptr type int
}

package main

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

// populateSliceUsingReflection 动态填充切片
// targetSliceType: 目标切片的 reflect.Type (例如 reflect.TypeOf([]int{}))
// stringValues: 待填充的字符串值切片 (例如 []string{"1", "2", "3"})
func populateSliceUsingReflection(targetSliceType reflect.Type, stringValues []string) (reflect.Value, error) {
    // 1. 检查目标类型是否为切片
    if targetSliceType.Kind() != reflect.Slice {
        return reflect.Value{}, fmt.Errorf("目标类型 %v 不是切片", targetSliceType)
    }

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

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

    // 4. 遍历字符串值，进行类型转换并填充切片
    for i, strVal := range stringValues {
        // 创建一个可设置的元素 reflect.Value
        // reflect.New(elemType) 返回一个指向 elemType 的指针 reflect.Value
        // .Elem() 解引用指针，得到 elemType 本身的可设置 reflect.Value
        elemValue := reflect.New(elemType).Elem()

        // 根据元素类型进行转换
        switch elemType.Kind() {
        case reflect.String:
            elemValue.SetString(strVal)
        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
            intVal, err := strconv.ParseInt(strVal, 10, elemType.Bits())
            if err != nil {
                return reflect.Value{}, fmt.Errorf("无法将 '%s' 转换为 %v 类型: %w", strVal, elemType, err)
            }
            elemValue.SetInt(intVal)
        case reflect.Float32, reflect.Float64:
            floatVal, err := strconv.ParseFloat(strVal, elemType.Bits())
            if err != nil {
                return reflect.Value{}, fmt.Errorf("无法将 '%s' 转换为 %v 类型: %w", strVal, elemType, err)
            }
            elemValue.SetFloat(floatVal)
        case reflect.Bool:
            boolVal, err := strconv.ParseBool(strVal)
            if err != nil {
                return reflect.Value{}, fmt.Errorf("无法将 '%s' 转换为 %v 类型: %w", strVal, elemType, err)
            }
            elemValue.SetBool(boolVal)
        default:
            return reflect.Value{}, fmt.Errorf("不支持的元素类型: %v", elemType)
        }

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

    return sliceValue, nil
}

func main() {
    // 示例1: 填充 []int
    targetIntSliceType := reflect.TypeOf([]int{})
    stringDataInt := []string{"10", "20", "30"}
    intSliceValue, err := populateSliceUsingReflection(targetIntSliceType, stringDataInt)
    if err != nil {
        fmt.Printf("填充 []int 失败: %v\n", err)
    } else {
        fmt.Printf("填充后的 []int 切片: %v (类型: %v)\n", intSliceValue.Interface(), intSliceValue.Type())
        // 验证类型和值
        if s, ok := intSliceValue.Interface().([]int); ok {
            fmt.Printf("转换回 []int: %v\n", s)
        }
    }
    fmt.Println("---")

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

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

    // 示例4: 错误处理 - 无法转换
    targetIntSliceTypeErr := reflect.TypeOf([]int{})
    stringDataErr := []string{"1", "abc", "3"}
    _, err = populateSliceUsingReflection(targetIntSliceTypeErr, stringDataErr)
    if err != nil {
        fmt.Printf("填充 []int (错误数据) 失败: %v\n", err)
    }
}