Go语言中 类型断言的理解和实现细节 以及最佳实践 (Golang经典编程案例)

语法：

1. <目标类型的值>，<布尔参数> := <表达式>.( 目标类型 ) // 安全类型断言

2. <目标类型的值> := <表达式>.( 目标类型 )　　//非安全类型断言

类型断言的本质：跟类型转换类似，都是类型之间进行转换，不同之处在于，类型断言实在接口之间进行，相当于Java中，对于一个对象，把一种接口的引用转换成另一种。

比如：

package main

import (
	"fmt"
)

func main() {

	var i interface{} = "kk"
	j := i.(int)
	fmt.Printf("%T->%d\n", j, j)
}

执行，会报如下错误：

var i interface{} = “KK” 某种程度上相当于java中的，Object i = “KK”;

现在把这个 i 转换成 int 类型，系统内部检测到这种不匹配，就会调用内置的panic()函数，抛出一个异常。改一下，把 i 的定义改为：var i interface{} = 99，就没问题了。

以上是不安全的类型断言。我们来看一下安全的类型断言：

package main

import (
	"fmt"
)

func main() {

	var i interface{} = "TT"
	j, b := i.(int)
	if b {
		fmt.Printf("%T->%d\n", j, j)
	} else {
		fmt.Println("类型不匹配")
	}
}

执行结果如下图所示：

最佳实践1：

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 (c Camera) Start() {
	fmt.Println("相机开始工作。。。")
}
func (c Camera) Stop() {
	fmt.Println("相机停止工作。。。")
}

type Computer struct {

}

func (computer Computer) Working(usb Usb) {
	usb.Start()
	//如果usb是指向Phone结构体变量，则还需要调用Call方法
	//类型断言..[注意体会!!!]
	if phone, ok := usb.(Phone); ok {
		phone.Call()
	}
	usb.Stop()
}

func main() {
	//定义一个Usb接口数组，可以存放Phone和Camera的结构体变量
	//这里就体现出多态数组
	var usbArr [3]Usb
	usbArr[0] = Phone{"vivo"}
	usbArr[1] = Phone{"小米"}
	usbArr[2] = Camera{"尼康"}

	//遍历usbArr
	//Phone还有一个特有的方法call()，请遍历Usb数组，如果是Phone变量，
	//除了调用Usb 接口声明的方法外，还需要调用Phone 特有方法 call. =》类型断言
	var computer Computer
	for _, v := range usbArr{
		computer.Working(v)
		fmt.Println()
	}
	//fmt.Println(usbArr)
}

执行结果如下图：

最佳实践2：

package main

import (
	"fmt"
)

//定义Student类型
type Student struct {

}

//编写一个函数，可以判断输入的参数是什么类型
func TypeJudge(items... interface{}) {
	for index, x := range items {
		switch x.(type) {
		case bool :
			fmt.Printf("第%v个参数是 bool 类型，值是%v\n", index, x)
		case float32 :
			fmt.Printf("第%v个参数是 float32 类型，值是%v\n", index, x)
		case float64 :
			fmt.Printf("第%v个参数是 float64 类型，值是%v\n", index, x)
		case int, int32, int64 :
			fmt.Printf("第%v个参数是 整数 类型，值是%v\n", index, x)
		case string :
			fmt.Printf("第%v个参数是 string 类型，值是%v\n", index, x)
		case Student :
			fmt.Printf("第%v个参数是 Student 类型，值是%v\n", index, x)
		case *Student :
			fmt.Printf("第%v个参数是 *Student 类型，值是%v\n", index, x)
		default :
			fmt.Printf("第%v个参数是  类型 不确定，值是%v\n", index, x)
		}
	}
}

func main() {

	var n1 float32 = 1.1
	var n2 float64 = 2.3
	var n3 int32 = 30
	var name string = "tom"
	address := "北京"
	n4 := 300

	stu1 := Student{}
	stu2 := &Student{}

	TypeJudge(n1, n2, n3, name, address, n4, stu1, stu2)
}

执行结果如下图所示：