x.(T) 检查x的动态类型是否是T，其中x必须是接口值。

• 如果T是具体类型
  类型断言检查x的动态类型是否等于具体类型T。如果检查成功，类型断言返回的结果是x的动态值，其类型是T。换句话说，对接口值x断言其动态类型是具体类型T，若成功则提取出x的具体值。如果检查失败则panic。
  例如：

var w io.Writer
w = os.Stdout  //os.Stdout是一个类型为*os.File的包级别变量
f := w.(*os.File) //断言接口w的动态类型是具体类型*os.File，断言成功，返回os.Stdout给f
c := w.(*bytes.Buffer) //断言接口w的动态类型是具体类型*bytes.Buffer，断言失败，panic

• 如果T是接口类型
  类型断言检查x的动态类型是否满足T。如果检查成功，x的动态值不会被提取，返回值是一个类型为T的接口值。换句话说，到接口类型的类型断言，改变了表达式的类型，改变了（通常是扩大了）可以访问的方法，且保护了接口值内部的动态类型和值。
  例如：

var w io.Writer
w = os.Stdout
rw := w.(io.ReadWriter) //成功：*os.File同时有Read和Write方法
w = new(ByteCounter)  //有Write方法
rw = w.(io.ReadWriter) // panic: *ByteCounter没有Read方法

• 无论T是什么类型，如果x是nil接口值，则类型断言失败。
• 类型断言到一个较少限制（较少方法）的接口类型基本是不需要的，因为这个行为和赋值一样(除了nil的情况)：

w = rw // io.ReadWriter赋值给io.Writer
w = rw.(io.Writer) //和上面一样，仅当rw为nil时失败，而上面如果rw为nil则w被赋值为nil

如果我们想知道类型断言是否失败，而不是失败时触发panic，可以使用返回两个值的版本：

y, ok := x.(T)

当检查成功时ok为true。例如：

var w io.Writer = os.Stdout
f, ok := w.(*os.File) //成功：f为os.Stdout，ok为true
b, ok := w.(*bytes.Buffer) //失败：b为零值，这里是nil， ok为false，no panic

ok值通常立刻用于决定是否执行下一步，惯用法：

if f, ok := w.(*os.File); ok {
    // ... use f ...
}

类型断言用于查询可能的行为，例子：

package main

import (
    "io"
    "os"
)

//这个例子展示了类型断言用于选择可能的行为，这儿如果一个io.Writer支持WriteString则可以直接使用，从而避免分配临时内存

func writeString(w io.Writer, s string) (n int, err error) {
    type stringWriter interface {
        WriteString(string) (n int, err error)
    }
    if sw, ok := w.(stringWriter); ok {
        //fmt.Print("<use WriteString>")
        return sw.WriteString(s) // avoid temporary copy
    }
    return w.Write([]byte(s)) // allocate temporary copy
}

func writeHeader(w io.Writer, contentType string) error {
    if _, err := writeString(w, "Content-Type: "); err != nil {
        return err
    }
    if _, err := io.WriteString(w, contentType); err != nil { //系统自带的io.WriteString实现和上面一样
        return err
    }
    return nil
}

func main() {
    writeHeader(os.Stdout, "test")
}

• 接口值可有包含各种不同的具体类型值，而类型断言就是用于从接口中动态的区分出各种具体的类型，从而可以使用具体的类型。

• Type Switches

switch x.(type){
case nil: // 如果x是nil
case int, uint: 
case bool:
case string;
default: //没有匹配上
}
//case的顺序是有意义的，因为可能同时满足多个接口，不可以用fallthrough, default的位置无所谓。

如果需要提取具体的值：

switch x := x.(type) { /* ... */  } //前面的x是一个局部变量，因为switch创建了一个词法域
//x的类型就是每个case的类型，如果case有多个类型，则类型为interface{}