Go语言中接口切片的类型检测与处理

package main

import (
    "fmt"
    "strconv" // 引入 strconv 包用于类型转换示例
)

// processValue 函数用于演示如何处理不同类型的接口值
func processValue(value interface{}) {
    switch v := value.(type) {
    case int:
        fmt.Printf("处理 int 类型: %d\n", v)
    case float64:
        fmt.Printf("处理 float64 类型: %.2f\n", v)
    case string:
        fmt.Printf("处理 string 类型: \"%s\"\n", v)
    case bool:
        fmt.Printf("处理 bool 类型: %t\n", v)
    case []interface{}: // 核心：检测到接口切片
        fmt.Println("检测到 []interface{} 类型切片，开始遍历元素:")
        for i, element := range v {
            fmt.Printf("  切片元素 %d: ", i)
            // 递归调用 processValue 处理切片中的每个元素
            // 这样可以处理嵌套的 []interface{} 或其他复杂类型
            processValue(element)
        }
    default:
        // 对于其他未知类型，打印其类型和值
        fmt.Printf("处理未知类型: %T, 值: %v\n", v, v)
    }
}

func main() {
    fmt.Println("--- 示例1: 处理单个非切片值 ---")
    processValue(123)
    processValue("hello Go")
    processValue(3.14159)
    processValue(true)
    processValue(struct{ Name string }{"Go Lang"}) // 结构体也是一种类型

    fmt.Println("\n--- 示例2: 处理 []interface{} 切片 ---")
    // 定义一个包含多种类型的 []interface{} 切片
    mixedSlice := []interface{}{
        100,
        "Go语言编程",
        3.14,
        true,
        []interface{}{"嵌套切片", 2023}, // 嵌套的 []interface{}
        map[string]string{"key": "value"}, // map 类型
    }

    // 假设这个 mixedSlice 是从某个地方获取到的 interface{} 类型变量
    var unknownValue interface{} = mixedSlice

    // 使用类型切换来检测和处理 unknownValue
    switch v := unknownValue.(type) {
    case []interface{}:
        fmt.Println("成功检测到最外层是 []interface{} 类型。")
        for i, elem := range v {
            fmt.Printf("  外部切片元素 %d: ", i)
            processValue(elem) // 调用处理函数处理切片中的每个元素
        }
    default:
        fmt.Printf("未知类型: %T, 值: %v\n", v, v)
    }

    fmt.Println("\n--- 示例3: 处理非 []interface{} 的切片 ---")
    // 注意：[]int 并不是 []interface{}
    intSlice := []int{1, 2, 3}
    var anotherUnknownValue interface{} = intSlice
    switch v := anotherUnknownValue.(type) {
    case []interface{}:
        fmt.Println("这是一个 []interface{} 类型切片。") // 不会进入此分支
    case []int:
        fmt.Printf("这是一个 []int 类型切片，元素: %v\n", v) // 会进入此分支
    default:
        fmt.Printf("未知类型: %T, 值: %v\n", v, v)
    }

    fmt.Println("\n--- 示例4: 原始问题中的类型转换尝试 ---")
    // 模拟原始问题中的场景
    var value1 interface{} = 123.45 // 假设 value1 是一个 float64
    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', 2, 64) // 保留两位小数
        fmt.Printf("value1 是 float64 类型，转换为字符串: %s\n", s)
    case []interface{}:
        fmt.Println("value1 是 []interface{} 类型。")
        // 这里可以继续遍历 v
    default:
        fmt.Printf("value1 是未知类型: %T, 值: %v\n", v, v)
    }

    value1 = []interface{}{"apple", 123, false} // 假设 value1 现在是一个 []interface{}
    switch v := value1.(type) {
    case []interface{}:
        fmt.Println("value1 现在是 []interface{} 类型。")
        for i, elem := range v {
            fmt.Printf("  元素 %d: %v (类型: %T)\n", i, elem, elem)
        }
    default:
        fmt.Printf("value1 是未知类型: %T, 值: %v\n", v, v)
    }
}