## 一、简单断言
直接定义一个interface类型变量，然后获取type判断
```
package main
import "fmt"
type Element interface{}
func main() {
var e Element = 100
switch value := e.(type) {
case int:
fmt.Println("int", value) // 这里的value也可以写成e.(int)，是一样的
case string:
fmt.Println("string", value)
default:
fmt.Println("unknown", value)
}
}
```
打印结果：
```
int 100
```
## 二、函数方式
以函数形式，传入interface参数
```
package main
import "fmt"
func add(a, b interface{}) {
switch t := a.(type) {
case int:
fmt.Printf("type [%T] add res[%d]\n", t, a.(int)+b.(int))
case int16:
fmt.Printf("type [%T] add res[%d]\n", t, a.(int16)+b.(int16))
case float32:
fmt.Printf("type [%T] add res[%f]\n", t, a.(float32)+b.(float32))
case float64:
fmt.Printf("type [%T] add res[%f]\n", t, a.(float64)+b.(float64))
default:
fmt.Printf("type [%T] not support!\n", t)
}
}
func main() {
add(1, 2)
add(int16(1), int16(2))
add(float32(1.1), float32(2.2))
add(float64(1.1), float64(2.2))
add(true, false)
}
```
打印结果：
```
type [int] add res[3]
type [int16] add res[3]
type [float32] add res[3.300000]
type [float64] add res[3.300000]
type [bool] not support!
```
## 三、先判断后使用
以上断言.(type)只能与switch配合使用，在使用前得用断言指明变量的类型，如果断言错误就会触发panic。
如果不想触发panic，先做判断再使用，如下：
```
package main
import "fmt"
func main() {
a := int16(2)
b := int32(3)
add(a, b)
}
func add(a, b interface{}) {
_, ok := a.(int32)
if !ok {
fmt.Println("error type assertion!")
} else {
fmt.Println(b)
}
}
```
打印结果：
```
error type assertion!
```
