浅谈 go 中断言的应用

类型断言

语法

varOfTypeA,ok = varOfInterfaceB.(TypeA)

即把 varOfInterfaceB 转换为  TypeA

varOfTypeA: 断言成功则是得到的新类型变量，如果断言则是 nil，且会报 panic
ok : 一个 bool， 用于判断断言是否成功，可以不存在，只有一个返回值就是 varOFTypeA
varOfInterfaceB: 接口实例变量，接口的动态类型
TypeA: 一个具体的类型，或者一个接口，如果是具体类型则判断 varOfInterfaceB 是否是此类型，如果是接口，这判断 varOfInterfaceB 的动态类型是否实现了此接口

例子

var b interface{ S() }

var a interface{} = 10
// a 是接口实例，动态类型是 int
// 判断 a 的动态类型是否是 string，此处 int 不是 string，故 failed
// 把 string 改为 int，这为 succesful
// 把 string 改为 b，则判断 a 是否为 接口 b，显然 failed
// 把 string 改为 interface{}，这判断 a 是否为空接口，故 successful
_, ok := a.(string)
if !ok {
	fmt.Println("failed")
} else {
	fmt.Println("successful")
}

// Animal 接口
type Animal interface {
	Speak(msg string)
}

type dog struct {
}

// dog 实现了 Animal 接口
func (d dog) Speak(msg string) {
	fmt.Println("dog say:" + msg)
}

type cat struct {
}

// cat 实现了 Animal 接口
func (c cat) Speak(msg string) {
	fmt.Println("cat say:" + msg)
}

func main() {
	// animal 是 Animal 接口的实例变量
	var animal Animal
    // 一个新接口
	type aa interface{ aaa(i string) }
	// animal 的动态类型变为 cat struct
	animal = cat{}

   // animal 的动态类型是 cat , cat 实现了 Animal 接口，故 successful
   // 若把 Animal 接口改为 aa 接口， animal 的动态类型是  cat, cat 没有实现 aa 接口，故 fialed
   // 若把 Animal 改为 cat{}, 则 animal 的动态类型就是 cat struct， 故 succeessful
   // 若把 Animal 改为 dog{} 或 int 或 string， 这 animal 的动态类型 是 cat，不符合，故 fialed
	_, ok := animal.(Animal)
	if !ok {
		fmt.Println("fialed!")
	} else {
		fmt.Println("successful!")
	}

}

判断 map 中 key 是否存在

dogs := map[string]int{"lily": 20, "lal": 18}
if _, ok := dogs["lucy"]; !ok {
	fmt.Println("Lucy not exsit!")
}

判断