Go语言中安全有效地处理[]interface{}切片：类型断言与类型切换

package main

import "fmt"

type S struct {
    text string
}

func main() {
    a := []interface{}{}
    b := []interface{}{}

    s := S{"hello"}
    t := S{"world"}

    a = append(a, s) // 将结构体 S 实例 s 添加到切片 a
    b = append(b, t) // 将结构体 S 实例 t 添加到切片 b
    a = append(a, b) // 将切片 b 添加到切片 a

    fmt.Println("切片 a 的内容:", a)
    // 输出: 切片 a 的内容: [{hello} [{world}]]
}

value, ok := interfaceVar.(ConcreteType)

package main

import "fmt"

type S struct {
    text string
}

func main() {
    a := []interface{}{}
    b := []interface{}{}

    s := S{"hello"}
    t := S{"world"}

    a = append(a, s)
    b = append(b, t)
    a = append(a, b)

    // 1. 断言切片 a 的第一个元素
    assertedS, ok := a[0].(S)
    if !ok {
        fmt.Println("a[0] 不是类型 S")
        // 错误处理逻辑
    } else {
        fmt.Printf("a[0] 成功断言为 S 类型: %+v\n", assertedS)
        // 现在可以访问 assertedS.text
        fmt.Println("a[0].text:", assertedS.text)
    }

    // 2. 断言切片 a 的第二个元素（它是一个 []interface{}）
    assertedB, ok := a[1].([]interface{})
    if !ok {
        fmt.Println("a[1] 不是类型 []interface{}")
        // 错误处理逻辑
    } else {
        fmt.Printf("a[1] 成功断言为 []interface{} 类型: %+v\n", assertedB)

        // 进一步断言 assertedB 中的元素
        if len(assertedB) > 0 {
            assertedT, ok := assertedB[0].(S)
            if !ok {
                fmt.Println("assertedB[0] 不是类型 S")
                // 错误处理逻辑
            } else {
                fmt.Printf("assertedB[0] 成功断言为 S 类型: %+v\n", assertedT)
                fmt.Println("assertedB[0].text:", assertedT.text)
            }
        }
    }
}

switch x.(type) {
case TypeA:
    // x 是 TypeA 类型时执行的代码
case TypeB:
    // x 是 TypeB 类型时执行的代码
default:
    // x 是其他类型时执行的代码
}

package main

import "fmt"

type S struct {
    text string
}

// ExtractSlice 函数递归地处理 []interface{} 切片中的元素
func ExtractSlice(data []interface{}) {
    for i, x := range data {
        fmt.Printf("处理索引 %d 的元素: ", i)
        switch val := x.(type) { // val 会自动获得 x 的具体类型
        case S:
            fmt.Printf("这是一个 S 结构体: %+v, text: %s\n", val, val.text)
        case []interface{}:
            fmt.Println("这是一个嵌套的 []interface{} 切片，递归处理...")
            ExtractSlice(val) // 递归调用自身处理嵌套切片
        case int:
            fmt.Printf("这是一个整数: %d\n", val)
        case string:
            fmt.Printf("这是一个字符串: %s\n", val)
        default:
            fmt.Printf("这是一个未知类型: %T, 值: %+v\n", x, x)
        }
    }
}

func main() {
    a := []interface{}{}
    b := []interface{}{}

    s := S{"hello"}
    t := S{"world"}

    a = append(a, s)
    b = append(b, t)
    a = append(a, b)
    a = append(a, 123)       // 添加一个整数
    a = append(a, "GoLang") // 添加一个字符串

    fmt.Println("开始提取切片 a 的内容:")
    ExtractSlice(a)
}