示例
assert.go
package main
import "fmt"
type Point struct {
x int
y int
}
func main() {
var a interface{}
var point Point = Point{1, 2}
a = point
var b Point
b = a.(Point) //类型断言
fmt.Println(b)
}
执行结果：
{1 2}
说明：在进行类型断言时，如果类型不匹配，就会报 panic，因此进行类型断言时，要确保原来的空接口指向的就是断言的类型。
类型断言检测
assert.go
package main
import (
"fmt"
)
func main() {
var x interface{}
var b float32 = 2.1
x = b
if y, ok := x.(float32); ok {
fmt.Printf("y 的类型是 %T 值是=%v \n", y, y)
} else {
fmt.Println("convert fail")
}
}
运行结果：
y 的类型是 float32 值是=2.1
最佳实践1
assert.go
package main
import "fmt"
// 定义一个接口
type Usb interface {
// 声明两个没有实现的方法
Start()
Stop()
}
type Phone struct {
Name string
}
// 让Phone 实现Usb接口的方法
func (p Phone) Start() {
fmt.Println("手机开始工作。。。")
}
func (p Phone) Stop() {
fmt.Println("手机停止工作。。。")
}
func (p Phone) Call() {
fmt.Println("手机打电话。。。")
}
type Camera struct {
Name string
}
// 让 Camera 实现Usb接口的方法
func (p Camera) Start() {
fmt.Println("相机开始工作。。。")
}
func (p Camera) Stop() {
fmt.Println("相机停止工作。。。")
}
// 计算机
type Computer struct {
}
// 编写一个方法 Working 方法，接收一个Usb接口类型的变量
// 只要实现了Usb 接口（所谓实现 Usb 接口，就是指实现了 Usb 接口声明所有方法）
func (c Computer) Working(usb Usb) { // usb 变量会根据传入的实参，来判断到底是Phone，还是camera
// 通过 usb 接口变量来调用 Start 和 Stop 方法
usb.Start()
usb.Stop()
//类型断言
if phone, ok := usb.(Phone); ok {
phone.Call()
}
}
func main() {
var usbArr [3]Usb
usbArr[0] = Phone{"Vivo"}
usbArr[1] = Phone{"小米"}
usbArr[2] = Camera{"尼康"}
var computer Computer
for _, v := range usbArr {
computer.Working(v)
fmt.Println()
}
}
执行结果：
手机开始工作。。。 手机停止工作。。。 手机打电话。。。 手机开始工作。。。 手机停止工作。。。 手机打电话。。。 相机开始工作。。。 相机停止工作。。。
最佳实践2
assert.go
package main
import "fmt"
type Student struct{}
func TypeJudge(items... interface{}) {
for k, v := range items {
switch v.(type) {
case bool:
fmt.Printf("第%v个参数是 bool 类型， 值是%v \n", k, v)
case float32:
fmt.Printf("第%v个参数是 float32 类型， 值是%v \n", k, v)
case float64:
fmt.Printf("第%v个参数是 float64 类型， 值是%v \n", k, v)
case int, int32, int64:
fmt.Printf("第%v个参数是 整数 类型， 值是%v \n", k, v)
case string:
fmt.Printf("第%v个参数是 string 类型， 值是%v \n", k, v)
case Student:
fmt.Printf("第%v个参数是 Student 类型， 值是%v \n", k, v)
case *Student:
fmt.Printf("第%v个参数是 *Student 类型， 值是%v \n", k, v)
default:
fmt.Printf("第%v个参数是 类型 不确定， 值是%v \n", k, v)
}
}
}
func main() {
var n1 float32 = 1.1
var n2 float64 = 2.1
var n3 int = 30
var name string = "tome"
address := "北京"
n4 := 300
stu1 := Student{}
stu2 := new(Student)
TypeJudge(n1, n2, n3, name, address, n4, stu1, stu2)
}
执行结果：
第0个参数是 float32 类型， 值是1.1
第1个参数是 float64 类型， 值是2.1
第2个参数是 整数 类型， 值是30
第3个参数是 string 类型， 值是tome
第4个参数是 string 类型， 值是北京
第5个参数是 整数 类型， 值是300
第6个参数是 Student 类型， 值是{}
第7个参数是 *Student 类型， 值是&{}