Go语言教程：深入理解[]interface{}切片的类型断言与遍历

package main

import (
    "fmt"
    "strconv"
)

func processValue(value interface{}) {
    switch v := value.(type) {
    case int:
        s := strconv.Itoa(v)
        fmt.Printf("处理整数: %s\n", s)
    case float64:
        s := strconv.FormatFloat(v, 'f', 2, 64)
        fmt.Printf("处理浮点数: %s\n", s)
    case string:
        fmt.Printf("处理字符串: %s\n", v)
    case []interface{}:
        fmt.Println("检测到 []interface{} 类型切片，开始遍历:")
        for i, element := range v {
            fmt.Printf("  切片元素 [%d]: %v (类型: %T)\n", i, element, element)
            // 如果需要，可以对切片内部的元素进行进一步的类型断言
            switch elem := element.(type) {
            case int:
                fmt.Printf("    内部元素是 int: %d\n", elem)
            case string:
                fmt.Printf("    内部元素是 string: %s\n", elem)
            // 可以添加更多类型处理
            default:
                fmt.Printf("    内部元素是未知类型: %v\n", elem)
            }
        }
    default:
        fmt.Printf("检测到未知类型: %v (类型: %T)\n", v, v)
    }
}

func main() {
    // 示例1: 整数
    processValue(123)

    // 示例2: 浮点数
    processValue(3.14159)

    // 示例3: 字符串
    processValue("Hello Go!")

    // 示例4: []interface{} 切片
    mySlice := []interface{}{1, "hello", 3.14, true, map[string]string{"key": "value"}}
    processValue(mySlice)

    // 示例5: 其他类型的切片 (不会匹配到 []interface{})
    intSlice := []int{10, 20, 30}
    processValue(intSlice) // 会匹配到 default
}

// ... (在 processValue 函数内部)
case []interface{}:
    fmt.Println("检测到 []interface{} 类型切片，开始遍历:")
    for i, element := range v { // v 是 []interface{} 类型
        fmt.Printf("  切片元素 [%d]: %v (类型: %T)\n", i, element, element)
        // 对切片内部的每个 interface{} 元素进行进一步的类型断言
        switch elem := element.(type) {
        case int:
            fmt.Printf("    内部元素是 int: %d\n", elem)
        case string:
            fmt.Printf("    内部元素是 string: %s\n", elem)
        case float64:
            fmt.Printf("    内部元素是 float64: %f\n", elem)
        case bool:
            fmt.Printf("    内部元素是 bool: %t\n", elem)
        case map[string]string:
            fmt.Printf("    内部元素是 map[string]string: %v\n", elem)
        default:
            fmt.Printf("    内部元素是未知类型: %v\n", elem)
        }
    }
// ...

func convertToIntSlice(data []interface{}) ([]int, error) {
    result := make([]int, 0, len(data))
    for _, item := range data {
        if val, ok := item.(int); ok {
            result = append(result, val)
        } else {
            return nil, fmt.Errorf("元素 %v (类型 %T) 无法转换为 int", item, item)
        }
    }
    return result, nil
}

func main() {
    mixedSlice := []interface{}{1, 2, 3, "four"}
    intOnlySlice := []interface{}{10, 20, 30}

    if converted, err := convertToIntSlice(intOnlySlice); err == nil {
        fmt.Printf("成功转换为 []int: %v\n", converted)
    } else {
        fmt.Printf("转换失败: %v\n", err)
    }

    if converted, err := convertToIntSlice(mixedSlice); err == nil {
        fmt.Printf("成功转换为 []int: %v\n", converted)
    } else {
        fmt.Printf("转换失败: %v\n", err)
    }
}