Golang的语言中提供了断言的功能。golang中的所有程序都实现了interface{}的接口，这意味着，所有的类型如string,int,int64甚至是自定义的struct类型都就此拥有了interface{}的接口，这种做法和java中的Object类型比较类似。那么在一个数据通过func funcName(interface{})的方式传进来的时候，也就意味着这个参数被自动的转为interface{}的类型。

    1. func funcName(a interface{}) string {
    2.      return string(a)
    3. }

    编译器会返回

    1. cannot convert a (type interface{}) to type string: need type assertion

    此时，意味着整个转化的过程需要类型断言。类型断言有以下几种形式：

    1）直接断言使用

    1. var a interface{}
    4. fmt.Println("Where are you,Jonny?", a.(string))

    但是如果断言失败一般会导致panic的发生。所以为了防止panic的发生，我们需要在断言前进行一定的判断

    1. value, ok := a.(string)

    如果断言失败，那么ok的值将会是false,但是如果断言成功ok的值将会是true,同时value将会得到所期待的正确的值。示例：

    1. value, ok := a.(string)
    2. if !ok {
    3.     fmt.Println("It's not ok for type string")
    4.     return
    5. }
    6. fmt.Println("The value is ", value)

    完整例子如下：

    1. package main
    4. import "fmt"
    7. /*
    8. func funcName(a interface{}) string {
    9.         return string(a)
    10. }
    11. */
    14. func funcName(a interface{}) string {
    15.         value, ok := a.(string)
    16.         if !ok {
    17.                 fmt.Println("It is not ok for type string")
    18.                 return ""
    19.         }
    20.         fmt.Println("The value is ", value)
    23.         return value
    24. }
    27. func main() {
    28.         //      str := "123"
    29.         //      funcName(str)
    30.         //var a interface{}
    31.         //var a string = "123"
    32.         var a int = 10
    33.         funcName(a)
    34. }

    2）配合switch使用

    1. var t interface{}
    2. t = functionOfSomeType()
    3. switch t := t.(type) {
    4. default:
    5.     fmt.Printf("unexpected type %T", t)       // %T prints whatever type t has
    6. case bool:
    7.     fmt.Printf("boolean %t\n", t)             // t has type bool
    8. case int:
    9.     fmt.Printf("integer %d\n", t)             // t has type int
    10. case *bool:
    11.     fmt.Printf("pointer to boolean %t\n", *t) // t has type *bool
    12. case *int:
    13.     fmt.Printf("pointer to integer %d\n", *t) // t has type *int
    14. }

    或者如下使用方法

    1. func sqlQuote(x interface{}) string {
    2.     if x == nil {
    3.         return "NULL"
    4.     } else if _, ok := x.(int); ok {
    5.         return fmt.Sprintf("%d", x)
    6.     } else if _, ok := x.(uint); ok {
    7.         return fmt.Sprintf("%d", x)
    8.     } else if b, ok := x.(bool); ok {
    9.         if b {
    10.             return "TRUE"
    11.         }
    12.         return "FALSE"
    13.     } else if s, ok := x.(string); ok {
    14.         return sqlQuoteString(s) // (not shown)
    15.     } else {
    16.         panic(fmt.Sprintf("unexpected type %T: %v", x, x))
    17.     }
    18. }