Go语言中接口切片（[]interface{}）的类型检测与数据处理

switch v := someInterfaceValue.(type) {
case []interface{}:
    // 当someInterfaceValue是[]interface{}类型时执行此处的代码
    // 此时v的类型就是[]interface{}
    fmt.Println("变量是一个[]interface{}切片")
    // 可以在此处对v进行操作
case int:
    fmt.Println("变量是int类型")
case string:
    fmt.Println("变量是string类型")
default:
    fmt.Printf("变量是未知类型: %T\n", someInterfaceValue)
}

func processInterfaceSlice(data interface{}) {
    switch v := data.(type) {
    case []interface{}:
        fmt.Println("检测到[]interface{}切片，开始遍历元素：")
        for i, element := range v {
            fmt.Printf("索引 %d: ", i)
            // 对每个元素进行二次类型断言
            switch elemType := element.(type) {
            case int:
                fmt.Printf("整数类型，值为 %d\n", elemType)
            case string:
                fmt.Printf("字符串类型，值为 \"%s\"\n", elemType)
            case float64:
                fmt.Printf("浮点数类型，值为 %.2f\n", elemType)
            case bool:
                fmt.Printf("布尔类型，值为 %t\n", elemType)
            default:
                fmt.Printf("未知类型，实际类型为 %T，值为 %v\n", element, element)
            }
        }
    default:
        fmt.Printf("输入的不是[]interface{}类型，实际类型为 %T\n", data)
    }
}

package main

import (
    "fmt"
    "strconv" // 用于整数和浮点数的字符串转换
)

func main() {
    // 示例1: 一个包含多种类型数据的[]interface{}切片
    var mixedData interface{} = []interface{}{
        123,
        "hello Go",
        3.14159,
        true,
        map[string]string{"key": "value"},
        []int{1, 2, 3},
    }

    fmt.Println("--- 处理 mixedData ---")
    processAndIdentifySlice(mixedData)

    fmt.Println("\n--- 处理 nonSliceData (非切片数据) ---")
    // 示例2: 一个非[]interface{}类型的数据
    var nonSliceData interface{} = 42
    processAndIdentifySlice(nonSliceData)

    fmt.Println("\n--- 处理 emptySlice (空切片) ---")
    // 示例3: 一个空的[]interface{}切片
    var emptySlice interface{} = []interface{}{}
    processAndIdentifySlice(emptySlice)

    fmt.Println("\n--- 处理 nilSlice (nil切片) ---")
    // 示例4: 一个nil []interface{}切片
    var nilSlice interface{} = ([]interface{})(nil)
    processAndIdentifySlice(nilSlice)

    fmt.Println("\n--- 原始问题中的场景模拟 ---")
    // 模拟原始问题中的场景
    var value1 interface{} = []interface{}{"item1", 123, 4.56}
    var s string
    switch v := value1.(type) {
    case int:
        s = strconv.Itoa(v)
        fmt.Printf("value1是int类型: %s\n", s)
    case float64:
        s = strconv.FormatFloat(v, 'f', 0, 64)
        fmt.Printf("value1是float64类型: %s\n", s)
    case []interface{}:
        fmt.Println("value1是[]interface{}类型，开始遍历：")
        for i, element := range v {
            fmt.Printf("  元素 %d: 类型 %T, 值 %v\n", i, element, element)
        }
    default:
        fmt.Printf("value1是未知类型: %T, 值为 %v\n", value1, value1)
    }
}

// 辅助函数，用于检测和处理传入的interface{}
func processAndIdentifySlice(data interface{}) {
    switch v := data.(type) {
    case []interface{}:
        fmt.Printf("变量是一个[]interface{}切片，长度为 %d\n", len(v))
        if len(v) == 0 {
            fmt.Println("  切片为空。")
            return
        }
        for i, element := range v {
            fmt.Printf("  索引 %d: ", i)
            switch elemType := element.(type) {
            case int:
                fmt.Printf("整数类型，值为 %d\n", elemType)
            case string:
                fmt.Printf("字符串类型，值为 \"%s\"\n", elemType)
            case float64:
                fmt.Printf("浮点数类型，值为 %.2f\n", elemType)
            case bool:
                fmt.Printf("布尔类型，值为 %t\n", elemType)
            case map[string]string:
                fmt.Printf("map[string