11. golang之类型断言的最佳实践

1.类型断言的最佳实践1—— 在前面的Usb接口案例做改进：

给Phone结构体增加一个特有的方法call()，当Usb接口接收的是Phone变量时，还需要调用call方法。

代码如下：

package main
import (
	"fmt"
)

// 1. 在前面的Usb接口案例做改进
// 给Phone结构体增加一个特有的方法call()，当Usb接口接收的是Phone变量时，还需要调用call方法

// 声明 / 定义
type Usb interface {
	// 声明了两个没有实现的方法
	Start()
	Stop()
}

type Phone struct {
	name string
}

// 让Phone 实现Usb接口的方法
func (p Phone) Start() {
	fmt.Println("phone start...")
}

func (p Phone) Stop() {
	fmt.Println("phone stop...")
}

func (p Phone) Call() {
	fmt.Println("phone start working...")
}

type Camera struct {
	name string
}

// 让Camera实现 Usb接口的方法
func (c Camera) Start() {
	fmt.Println("camera start working...")
}

func (c Camera) Stop() {
	fmt.Println("carmera stop working...")
}

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{"华为"}
	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()
	}
}

2.  类型断言的最佳实践2——写一函数，循环判断传入参数的类型

x.(type) 这种方式的类型断言，就只能和 switch 搭配使用，因为它需要和多种类型比较判断，以确定其具体类型。

package main
import (
	"fmt"
)

// 2. 类型断言的最佳实践2：编写一个函数，可以判断输入的参数是什么类型
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)
			default:
				fmt.Printf("第%v个参数 类型不确定，值是%v\n",index,x)
		}
	}
}

func main() {
	var n1 float32 = 1.1
	var n2 float64 = 2.2
	var n3 int32 = 30
	var name string = "tom"
	address := "北京"
	n4 := 300
	TypeJudge(n1,n2,n3,n4,name,address)
}

3. 类型断言的最佳实践3

在2的基础上增加判断Student类型和*Student类型

package main
import (
	"fmt"
)

// 2. 类型断言的最佳实践2：编写一个函数，可以判断输入的参数是什么类型
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类型，值是\n",index,x)
			default:
				fmt.Printf("第%v个参数 类型不确定，值是%v\n",index,x)
		}
	}
}
type Student struct {}
func main() {
	var n1 float32 = 1.1
	var n2 float64 = 2.2
	var n3 int32 = 30
	var name string = "tom"
	address := "北京"
	n4 := 300
	var stu Student
	TypeJudge(n1,n2,n3,n4,name,address,stu,&stu)
}