Go 类型选择(type switch)

在 Go 语言中,如果只需要判断接口变量是不是某一种具体类型,使用类型断言 if v, ok := x.(int); ok 非常直接。但如果这个变量里面装的可能是 int、string、bool 等好几种不同的类型,连续写一长串 if...else 就会显得很繁琐。

针对这种需要同时判断多种类型的场景,Go 语言专门提供了 “类型选择(type switch)” 语法。它可以根据接口变量内部实际存放的数据类型,自动跳转到对应的分支执行代码。

type switch 语法

在 Go 语言中,类型选择可以看作是 switch 语句与类型断言的结合体:它把 x.(T) 小括号里的具体类型名换成了固定的关键字 type,再交给各个 case 分支去匹配。

语法:

switch 变量名 := 接口变量.(type) {
case 类型1:
    // 代码块 1
case 类型2:
    // 代码块 2
default:
    // 默认代码块
}

说明:

在使用 type switch 时,我们需要掌握以下 3 条基本规则:

  • 固定使用关键字 type:在 x.(type) 中,小括号里面必须固定写关键字 type,用来获取接口变量 x 内部实际存放的数据类型。
  • case 后面写类型名:普通 switch 语句的 case 后面写的是具体的 “值”(如 case 1:),而 type switch 的 case 后面直接写具体的 “类型名”(如 case int:)。
  • 接收变量自动转换类型:当匹配进入某个单一类型的 case 分支后,左边的接收变量会自动变成该分支对应的类型,我们在分支内部可以直接使用。

需要特别注意的是,.(type) 是 switch 语句的专属写法,我们不能脱离 switch 语句单独使用它。下面这种写法就是错误的。

var x any = 10
v := x.(type)    // 编译报错

如果在 switch 外面单独写 v := x.(type),编译时就会直接报错 “use of .(type) outside type switch”,提示不能在类型选择语句外部使用 .(type)。

注意:

  • 无需 break,禁止 fallthrough:每个 case 分支执行完后都会自动结束,不需要手动写 break。此外,分支中不允许使用 fallthrough 向下穿透,因为不同分支对应的变量类型各不相同。
  • 只能用于接口变量:与类型断言一样,x.(type) 左侧的 x 必须是接口类型的变量。如果我们拿普通的 int 或 string 变量去写 switch a.(type),编译时会直接报错。

type switch 示例

下面我们通过几个递进的例子,来看看 type switch 在不同场景下的具体用法。

示例 1:按类型执行不同操作

package main

import "fmt"

func checkType(x any) {
    switch v := x.(type) {
    case int:
        fmt.Printf("整数:%d,乘以 2 的结果:%d\n", v, v * 2)
    case string:
        fmt.Printf("字符串:%s,字节长度:%d\n", v, len(v))
    case bool:
        fmt.Printf("布尔值:%v\n", v)
    default:
        fmt.Printf("其他类型:%T,值为:%v\n", v, v)
    }
}

func main() {
    checkType(10)
    checkType("Hello")
    checkType(true)
    checkType(3.14)
}

运行结果如下。

整数:10,乘以 2 的结果:20
字符串:Hello,字节长度:5
布尔值:true
其他类型:float64,值为:3.14

分析:

checkType() 函数的参数 x 属于空接口,函数内部通过 switch v := x.(type) 对传入数据的具体类型做分支匹配。

观察各个分支的代码可以发现一个很省心的地方:当匹配进入 case int: 分支时,变量 v 的类型自动就是 int,我们可以直接计算 v * 2。当匹配进入 case string: 分支时,v 的类型自动就是 string,可以直接调用 len(v) 获取字节长度。

当我们第 4 次调用并传入小数 3.14 时,由于它属于 float64 类型,前面的 case 分支都没有匹配上,程序就会自动进入 default 分支。

如果在判断类型之后,我们不需要在分支里读取变量的具体值,还可以把写法进一步简化。我们来看下面这个例子。

示例 2:省略接收变量

package main

import "fmt"

func printCategory(x any) {
    // 省略左边的变量接收
    switch x.(type) {
    case int:
        fmt.Println("传入的是一个整数")
    case string:
        fmt.Println("传入的是一个字符串")
    default:
        fmt.Println("传入的是其他类型")
    }
}

func main() {
    printCategory(2026)
    printCategory("绿叶网")
}

运行结果如下。

传入的是一个整数
传入的是一个字符串

分析:

switch x.(type) 表示省去了左边的 v :=。在 Go 语言中,如果我们声明了局部变量却不在代码里使用,编译器会直接报错。因此当我们只需要判断接口变量属于哪种类型、不需要读取它的具体值时,直接写成 switch x.(type) 就可以了。

除了一个分支只写一种类型之外,如果好几种类型的处理逻辑相同,我们还可以在同一个 case 后面使用英文逗号(,)并列写出多个类型名,或者使用 case nil: 匹配未赋值的空接口。请看下面这个例子。

示例 3:单分支匹配多种类型

package main

import "fmt"

func classify(x any) {
    switch v := x.(type) {
    case int, int64:
        fmt.Printf("整数类型:%v\n", v)
    case float32, float64:
        fmt.Printf("浮点数类型:%v\n", v)
    case nil:
        fmt.Println("空值 nil")
    default:
        fmt.Printf("其他类型:%v\n", v)
    }
}

func main() {
    classify(100)
    classify(3.14)
    classify(nil)
    classify("Go")
}

运行结果如下。

整数类型:100
浮点数类型:3.14
空值 nil
其他类型:Go

分析:

上面代码中,case int, int64: 可以同时匹配两种整数类型,case float32, float64: 可以同时匹配两种浮点数类型,而当我们传入 nil 时则会命中 case nil: 分支。

这里小伙伴们要留意一个小细节:当一个 case 后面并列写了多个类型(如 case int, int64:)时,编译器无法确定进来的到底是 int 还是 int64。

因此在该分支内部,变量 v 的类型仍然保持为原本的 any,default: 分支里的 v 同样保持原来的接口类型。它们都不能像示例 1 那样直接写 v * 2 参与算术运算。

如果我们希望把同一套算术计算代码直接复用到 int、int64、float64 等多种数值类型上,使用下一章学习的泛型会更加合适。

前面几个例子判断的都是 any 空接口。实际上,普通的非空接口变量同样可以使用 type switch 来区分内部存放的是哪一种结构体,并调用该结构体独有的方法。

示例 4:匹配接口中的结构体

package main

import "fmt"

type USB interface {
    Connect()
}

type Mouse struct {
    Name string
}

func (m Mouse) Connect() {
    fmt.Println(m.Name, "已连接")
}

func (m Mouse) Click() {
    fmt.Println(m.Name, "执行左键点击")
}

type Disk struct {
    Name string
}

func (d Disk) Connect() {
    fmt.Println(d.Name, "已连接")
}

func (d Disk) ReadData() {
    fmt.Println(d.Name, "正在读取文件")
}

func checkUSB(u USB) {
    u.Connect()

    switch dev := u.(type) {
    case Mouse:
        dev.Click()
    case Disk:
        dev.ReadData()
    }
}

func main() {
    checkUSB(Mouse{Name: "无线鼠标"})
    checkUSB(Disk{Name: "移动硬盘"})
}

运行结果如下。

无线鼠标 已连接
无线鼠标 执行左键点击
移动硬盘 已连接
移动硬盘 正在读取文件

分析:

checkUSB(u USB) 接收的是普通的 USB 接口参数,直接通过 u 只能调用公共的 Connect() 方法。

进入 switch dev := u.(type) 后,当匹配到 case Mouse: 分支时,dev 会自动还原为 Mouse 结构体并调用 Click() 方法。当匹配到 case Disk: 分支时,dev 则自动还原为 Disk 结构体并调用 ReadData() 方法。

需要注意的是,如果调用时传入的是结构体指针(如 &Mouse{}),那么分支里也要对应写成指针类型 case *Mouse:。

提示: 在实际开发中,关于类型断言和类型选择的选型,小伙伴们只需要记住一个简单的原则:如果只需要判断 1 种具体类型,使用 if v, ok := x.(T); ok 最直接。如果需要同时判断 2 种及以上不同的类型,使用 switch v := x.(type) 会清晰得多。

上一篇:

下一篇:

给站长反馈

绿叶网正在不断完善中,小伙伴们如果发现任何问题,还望多多给站长反馈,谢谢!

邮箱:lvyenet@vip.qq.com

「绿叶网」服务号
绿叶网服务号放大
关注服务号,微信也能看教程。
绿叶网服务号