当我们把整数 10 存入空接口变量 var x any = 10 后,如果直接写 x + 20 计算加法,编译器会立刻报错。这是因为编译器表面上只知道 x 是空接口,并不能确定它里面实际装的是什么数据。
如果想要检查一个接口变量内部装的是不是某个具体类型,并把里面的值提取出来参与计算,我们就需要使用 Go 语言提供的 “类型断言(Type Assertion)”。其中,assertion 在英文中就是 “断言、断定” 的意思。
单返回值类型断言
在 Go 语言中,我们可以在接口变量后面加上英文点号(.)和小括号来指定目标类型,最基础的写法只返回一个提取结果。
语法:
变量名 := 接口变量.(目标类型)说明:
小括号里填写希望还原的具体数据类型(如 int、string)。这条语句的作用是:断定接口变量内部当前存放的就是目标类型的数据,并将其提取出来赋值给左边的变量。
如果接口变量内部存放的确实是该目标类型,类型断言就会成功,左边的变量也会变成真正的目标类型。
示例 1:提取空接口中的值
package main
import "fmt"
func main() {
var x any = 10
// 断言还原为 int 类型
num := x.(int)
// 还原后参与算术运算
fmt.Println(num + 20)
}运行结果如下。
30分析:
num := x.(int) 这句代码表示把空接口变量 x 里面存放的整数 10 提取出来。此时变量 num 的类型就是真正的 int 类型,因此后面执行 num + 20 就能正常算出结果 30。
不过,这种单返回值的写法隐藏着一个风险:如果接口变量 x 里面实际装的数据并不是我们指定的目标类型,程序在运行时会发生什么呢?下面我们来看一个例子。
示例 2:断言类型不匹配
package main
import "fmt"
func main() {
var x any = "Hello"
// 实际存放 string,强行断言为 int
num := x.(int)
fmt.Println(num)
}运行结果如下。
(报错)panic: interface conversion: interface {} is string, not int分析:
从运行结果可以看出,变量 x 内部实际存放的是字符串 "Hello",而 x.(int) 却强行把它当作 int 类型提取。程序在运行时直接触发 panic 崩溃,并提示接口内部实际是 string 而不是 int。
同样地,如果接口变量本身是尚未赋值的 nil(比如只写了 var x any),直接对它执行 x.(int) 也会触发 panic 崩溃,因为空的接口里根本没有存放任何具体的值。
注意:
- 只能用于接口变量:类型断言
x.(T)只能使用在接口类型的变量上。如果a本身就是一个普通的非接口变量(如a := 10),对它写a.(int)会直接触发编译报错。 - 区分类型断言与类型转换:普通类型转换
T(x)是把已知类型转换成另一种新类型(如把int转为float64)。而类型断言x.(T)则是把接口变量里原本存着的值按原样 “拆箱” 取出来。
双返回值类型断言(推荐)
为了避免类型不匹配时程序直接崩溃,我们在接收类型断言的结果时,可以多接收一个布尔类型的返回值 ok 来判断断言是否成功。这与前面在 Map 中判断键是否存在时的 v, ok := m[key] 写法非常相似。
语法:
值变量, 布尔变量 := 接口变量.(目标类型)说明:
与单返回值写法相比,双返回值断言具有以下 2 个特点:
- 断言成功时:布尔变量返回
true,值变量返回提取出来的真实数据。 - 断言失败时:程序不会触发
panic崩溃,而是将布尔变量设为false,同时将值变量设为目标类型的默认零值(如0、""、false)。哪怕接口变量本身为nil,也能安全返回false。
示例 3:安全的双返回值断言
package main
import "fmt"
func main() {
var x any = "绿叶网"
// 1. 断言为 string 类型
if s, ok := x.(string); ok {
fmt.Printf("提取成功:%s\n", s)
}
// 2. 断言为 int 类型
if n, ok := x.(int); ok {
fmt.Printf("提取成功:%d\n", n)
} else {
fmt.Printf("断言失败:ok=%v, n=%d\n", ok, n)
}
}运行结果如下。
提取成功:绿叶网
断言失败:ok=false, n=0分析:
在这个例子中,变量 x 里面存放的是字符串 "绿叶网"。当我们第 1 次执行 s, ok := x.(string) 时,类型匹配成功,ok 的值为 true,程序顺利打印出 "绿叶网"。
当我们第 2 次执行 n, ok := x.(int) 时,由于 x 并不是 int 类型,断言匹配失败。但因为我们接收了第 2 个返回值 ok,程序并没有像示例 2 那样崩溃,而是正常进入了 else 分支,此时 ok 为 false、n 为 int 的默认零值 0。
对于双返回值断言配合 if 判断,下面 2 种写法是等价的。
// 方式 1(推荐)
if s, ok := x.(string); ok {
fmt.Println(s)
}
// 方式 2
s, ok := x.(string)
if ok {
fmt.Println(s)
}其中,方式 1 把类型断言和 ok 判断紧凑地写在同一行,并且变量 s 只在当前 if 代码块内生效,在实际开发中我们更推荐使用方式 1。除非能够 100% 确定接口变量里装的就是某个固定类型,否则平时写代码时小伙伴们都应该优先使用带 ok 的双返回值断言。
提示: 如果一个接口变量只可能是某一种具体类型,使用 if v, ok := x.(T); ok 判断非常方便。但如果它可能是 int、string、bool 等多种类型,连续写多个 if...else 就会显得繁琐,此时可以使用下一节介绍的类型选择来处理。
将接口还原为结构体或另一接口
除了用于 any 空接口之外,类型断言也常用于普通的接口。当函数接收某个接口作为参数时,通过该接口参数只能调用接口里规定的公共方法。如果我们在函数内部还想调用某一种结构体独有的方法,就可以通过类型断言将其还原为对应的结构体类型。
示例 4:将接口还原为结构体
package main
import "fmt"
type Speaker interface {
Speak()
}
type Dog struct {
Name string
}
func (d Dog) Speak() {
fmt.Println(d.Name, "汪汪汪")
}
// Dog 独有的方法
func (d Dog) LookAfterHouse() {
fmt.Println(d.Name, "正在看家")
}
type Cat struct {
Name string
}
func (c Cat) Speak() {
fmt.Println(c.Name, "喵喵喵")
}
func checkAnimal(s Speaker) {
s.Speak()
// 判断 s 内部是不是 Dog 结构体
if dog, ok := s.(Dog); ok {
dog.LookAfterHouse()
}
}
func main() {
checkAnimal(Dog{Name: "旺财"})
checkAnimal(Cat{Name: "咪咪"})
}运行结果如下。
旺财 汪汪汪
旺财 正在看家
咪咪 喵喵喵分析:
Speaker 接口只规定了 Speak() 方法,而 Dog 结构体除了实现该方法外,还有一个独有的 LookAfterHouse() 方法。在 checkAnimal(s Speaker) 函数中,参数 s 是接口类型,直接写 s.LookAfterHouse() 会编译报错。
加上 if dog, ok := s.(Dog); ok 判断后,当我们传入 Dog 时,就能把它安全还原为 dog 变量并调用 LookAfterHouse()。当我们传入 Cat 时,ok 的值为 false,程序会自动跳过这个 if 分支。
在实际开发中,我们经常会把结构体指针赋给接口变量。这里小伙伴们要特别留意:类型断言小括号里的目标类型,必须与存进接口时的真实类型完全一致。
如果存进去的是结构体值 Dog{},就应该断言为 s.(Dog);如果存进去的是结构体指针 &Dog{},就必须断言为 s.(*Dog)。
var s Speaker = &Dog{Name: "旺财"}
// 正确方式
dog1, ok := s.(*Dog)
// 错误方式
dog2, ok := s.(Dog)在上面的错误方式中,接口变量 s 内部实际保存的是指针类型 *Dog。此时如果写成 s.(Dog) 去断言值类型,类型就匹配不上了,返回的 ok 会变成 false。只有写成 s.(*Dog),才能成功提取出里面的结构体指针。
此外,类型断言的小括号里不仅可以写结构体等具体类型,还可以写另一个接口类型,用来判断当前接口变量内部的对象是否同时具备另一组能力。下面我们来看一个例子。
示例 5:将接口断言为另一个接口
package main
import "fmt"
type Reader interface {
Read()
}
type ReadWriter interface {
Read()
Write()
}
type File struct {
Name string
}
func (f File) Read() {
fmt.Printf("正在读取文件:%s\n", f.Name)
}
func (f File) Write() {
fmt.Printf("正在写入文件:%s\n", f.Name)
}
func main() {
var r Reader = File{Name: "data.txt"}
r.Read()
// 判断 r 内部的对象是否同时实现了 ReadWriter 接口
if rw, ok := r.(ReadWriter); ok {
rw.Write()
}
}运行结果如下。
正在读取文件:data.txt
正在写入文件:data.txt分析:
变量 r 表面上是只负责读取的 Reader 接口,但它内部实际存放的 File 结构体同时实现了 Write() 方法。通过 if rw, ok := r.(ReadWriter); ok,我们就能在运行时安全判断并拿到 ReadWriter 接口,从而调用 rw.Write()。
这也正好解决了前面学习接口嵌套与组合时,子接口变量不能直接赋值给大接口变量的问题。
