Go语言中安全解析[]interface{}切片：类型断言与类型切换实践

value, ok := x.(T)

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) // a 现在包含 S{"hello"}
    b = append(b, t) // b 现在包含 S{"world"}
    a = append(a, b) // a 现在包含 S{"hello"} 和 []interface{}{S{"world"}}

    // 1. 断言第一个元素
    assertedS, ok := a[0].(S)
    if !ok {
        fmt.Println("a[0] is not of type S")
        // 进行错误处理，例如 log.Fatal("...") 或返回错误
        return
    }
    fmt.Printf("第一个元素 (S): %+v\n", assertedS)

    // 2. 断言第二个元素，它是一个 []interface{}
    assertedB, ok := a[1].([]interface{})
    if !ok {
        fmt.Println("a[1] is not of type []interface{}")
        // 进行错误处理
        return
    }
    fmt.Printf("第二个元素 ([]interface{}): %+v\n", assertedB)

    // 3. 从嵌套切片中断言元素
    if len(assertedB) > 0 {
        assertedT, ok := assertedB[0].(S)
        if !ok {
            fmt.Println("assertedB[0] is not of type S")
            // 进行错误处理
            return
        }
        fmt.Printf("嵌套切片中的第一个元素 (S): %+v\n", assertedT)
    }
}

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

package main

import "fmt"

type S struct {
    text string
}

func ExtractSlice(slice []interface{}) {
    for i, x := range slice {
        switch val := x.(type) {
        case S:
            fmt.Printf("索引 %d: 发现 S 类型值: %+v\n", i, val)
        case []interface{}:
            fmt.Printf("索引 %d: 发现嵌套 []interface{}，递归处理...\n", i)
            ExtractSlice(val) // 递归调用处理嵌套切片
        default:
            fmt.Printf("索引 %d: 发现未知类型值: %T (值: %+v)\n", i, val, val)
        }
    }
}

func main() {
    a := []interface{}{}
    b := []interface{}{}
    c := []interface{}{} // 增加一个更深的嵌套层

    s1 := S{"first_string"}
    s2 := S{"second_string"}
    s3 := S{"third_string"}

    a = append(a, s1)
    b = append(b, s2)
    c = append(c, s3)
    b = append(b, c) // b 现在包含 S{"second_string"} 和 []interface{}{S{"third_string"}}
    a = append(a, b) // a 现在包含 S{"first_string"} 和 [S{"second_string"}, []interface{}{S{"third_string"}}]
    a = append(a, 123) // 增加一个 int 类型元素

    fmt.Println("开始提取切片元素:")
    ExtractSlice(a)
}

开始提取切片元素:
索引 0: 发现 S 类型值: {text:first_string}
索引 1: 发现嵌套 []interface{}，递归处理...
索引 0: 发现 S 类型值: {text:second_string}
索引 1: 发现嵌套 []interface{}，递归处理...
索引 0: 发现 S 类型值: {text:third_string}
索引 2: 发现未知类型值: int (值: 123)