Go 语言中 interface{} 的类型判断与安全转换指南

package main

import "fmt"

func weirdFunc(i int) interface{} {
    if i == 0 {
        return "zero" // 返回一个字符串
    }
    return i // 返回一个整数
}

func main() {
    var w1 = weirdFunc(0) // w1 的底层类型是 string
    var w2 = weirdFunc(5) // w2 的底层类型是 int

    fmt.Printf("w1 的动态类型是 %T，w2 的动态类型是 %T\n", w1, w2)
}

concreteValue, ok := interfaceValue.(Type)

package main

import "fmt"

func weirdFunc(i int) interface{} {
    if i == 0 {
        return "zero"
    }
    return i
}

func main() {
    var i = 5
    var w = weirdFunc(5) // w 持有 int 类型的值 5

    // 使用类型断言安全地提取 int 值
    if tmp, ok := w.(int); ok {
        i += tmp // 此时 tmp 已经被断言为 int 类型，可以直接进行数学运算
        fmt.Println("w 被断言为 int 类型，i =", i)
    } else {
        fmt.Println("w 不是 int 类型")
    }

    var wStr = weirdFunc(0) // wStr 持有 string 类型的值 "zero"
    if s, ok := wStr.(string); ok {
        fmt.Println("wStr 被断言为 string 类型，值为:", s)
    } else {
        fmt.Println("wStr 不是 string 类型")
    }

    // 尝试将 wStr 断言为 float64，会失败
    if f, ok := wStr.(float64); ok {
        fmt.Println("wStr 被断言为 float64 类型，值为:", f)
    } else {
        fmt.Println("wStr 不是 float64 类型，断言失败。")
    }
}

switch v := interfaceValue.(type) {
case Type1:
    // v 在这里是 Type1 类型
case Type2:
    // v 在这里是 Type2 类型
default:
    // v 在这里仍然是 interface{} 类型，或者如果你在 case 中没有重新声明，则保持原类型
}

package main

import "fmt"

func processInterface(myInterface interface{}) {
    switch v := myInterface.(type) {
    case int:
        // v 在此 case 中已被推断为 int 类型
        fmt.Printf("处理整数类型: %v, 加 1 后为 %v\n", v, v+1)
    case float64:
        // v 在此 case 中已被推断为 float64 类型
        fmt.Printf("处理浮点数类型: %v, 加 1.0 后为 %v\n", v, v+1.0)
    case string:
        // v 在此 case 中已被推断为 string 类型
        fmt.Printf("处理字符串类型: %v, 拼接后为 \"%v Yeah!\"\n", v, v+" Yeah!")
    case bool:
        // v 在此 case 中已被推断为 bool 类型
        fmt.Printf("处理布尔类型: %v\n", v)
    default:
        // 如果没有匹配的 case，则执行 default 分支
        // v 在 default 分支中仍然是 interface{} 类型
        fmt.Printf("无法识别的类型: %T, 值为 %v\n", v, v)
    }
}

func main() {
    processInterface(10)
    processInterface(3.14)
    processInterface("Hello Go")
    processInterface(true)
    processInterface([]int{1, 2, 3}) // 这是一个切片类型，会进入 default 分支
}

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var i interface{} = 123
    var s interface{} = "hello"
    var b interface{} = true

    // 获取 interface{} 值的底层类型
    t1 := reflect.TypeOf(i)
    t2 := reflect.TypeOf(s)
    t3 := reflect.TypeOf(b)

    fmt.Printf("i 的真实类型是: %v (Kind: %v)\n", t1, t1.Kind())
    fmt.Printf("s 的真实类型是: %v (Kind: %v)\n", t2, t2.Kind())
    fmt.Printf("b 的真实类型是: %v (Kind: %v)\n", t3, t3.Kind())

    // 获取类型名称的字符串表示
    fmt.Printf("i 的类型字符串是: %s\n", t1.String())
    fmt.Printf("s 的类型字符串是: %s\n", t2.String())
}