Go基礎系列：接口類型斷言和type-switch

接口轉回成具體類型

接口實例中能夠存放各類實現了接口的類型實例，在有須要的時候，還能夠經過ins.(Type)或ins.(*Type)的方式將接口實例ins直接轉回Type類型的實例。

var i int = 30
var ins interface{}

// 接口實例ins中保存的是int類型
ins = i
x := ins.(int)  // 接口轉回int類型的實例i
println(x) //輸出30

但注意，這時候的i和x在底層不是同一個對象，它們的地址是不一樣的。

var i int = 30
var ins interface{}

ins = i
x := ins.(int)
println("i addr: ",&i,"x addr: ",&x)

輸出：

0xc042049f68
0xc042049f60

注意，接口實例轉回時，接口實例中存放的是什麼類型，才能轉換成什麼類型。同類型的值類型實例和指針類型實例不能互轉，不一樣類型更不能互轉。

在不能轉換時，Golang將直接以Panic的方式終止程序。但能夠處理轉換失敗時的panic，這時須要類型斷言，也即類型檢測。

接口類型探測：類型斷言

類型探測的方式和類型轉換的方式都是ins.(Type)和ins.(*Type)。當處於單個返回值上下文時，作的是類型轉換，當處於兩個返回值的上下文時，作的是類型探測。類型探測的第一個返回值是類型轉換以後的類型實例，第二個返回值是布爾型的ok返回值。

// 若是ins保存的是值類型的Type，則輸出
if t, ok := ins.(Type); ok {
    fmt.Printf("%T\n", v)
}

// 若是ins保存的是指針類型的*Type，則輸出
if t, ok := ins.(*Type); ok {
    fmt.Printf("%T\n", v)
}

// 一個返回值的探測
t := ins.(Type)
t := ins.(*Type)

如下是一個例子：

package main

import "fmt"

// Shaper 接口類型
type Shaper interface {
    Area() float64
}

// Square struct類型
type Square struct {
    length float64
}

// Square類型實現Shaper中的方法Area()
func (s Square) Area() float64 {
    return s.length * s.length
}

func main() {
    var ins1, ins2 Shaper

    // 指針類型的實例
    s1 := new(Square)
    s1.length = 3.0
    ins1 = s1
    if v, ok := ins1.(*Square); ok {
        fmt.Printf("ins1: %T\n", v)
    }

    // 值類型的實例
    s2 := Square{4.0}
    ins2 = s2
    if v, ok := ins2.(Square); ok {
        fmt.Printf("ins2: %T\n", v)
    }
}

上面兩個Printf都會輸出，由於它們的類型判斷都返回true。若是將ins2.(Square)改成ins2.(*Square)，第二個Printf將不會輸出，由於ins2它保存的是值類型的實例。

如下是輸出結果：

ins1: *main.Square
ins2: main.Square

特別須要注意的是，ins必須明確是接口實例。例如，如下前兩種聲明是有效的，第三種推斷類型是錯誤的，由於它多是接口實例，也多是類型的實例副本。

var ins Shaper     // 正確
ins := Shaper(s1)  // 正確
ins := s1          // 錯誤

當ins不能肯定是接口實例時，用它來進行測試，例如ins.(Square)將會報錯：

invalid type assertion:ins.(Square) (non-interface type (type of ins) on left)

它說明了左邊的ins是非接口類型(non-interface type)。

另外一方面，經過接口類型斷言(ins.(Type))，若是Type是一個接口類型，就能夠判斷接口實例ins中所保存的類型是否也實現了Type接口。例如：

var r io.Read
tty, err := os.OpenFile("/dev/tty", os.O_RDWR, 0)
if err != nil {
    return nil, err
}
r = tty

var w io.Writer
w = r.(io.Writer)

上面的r是io.Read接口的一個實例變量，它裏面保存的是tty和它的類型，即(tty, *os.File)，而後斷言r的類型，探測它裏面的類型*File是否也實現了io.Writer接口，若是實現了，則保存到io.Writer接口的實例變量w中，這樣w實例也將保存(tty,*os.File)。

因爲任意內容都實現了空接口，因此，老是能夠把一個接口實例無需經過任何斷言地賦值給一個空接口實例：

var empty interface{}
empty = w

如今empty也保存了(tty,*os.File)。

type Switch結構

直接用if v,ok := ins.(Type);ok {}的方式作類型探測在探測類型數量多時不是很方便，須要重複寫if結構。

Golang提供了switch...case結構用於作多種類型的探測，因此這種結構也稱爲type-switch。這是比較方便的語法，好比能夠判斷某接口若是是A類型，就執行A類型裏的特有方法，若是是B類型，就執行B類型裏的特有方法。

用法以下：

switch v := ins.(type) {
case *Square:
    fmt.Printf("Type Square %T\n", v)
case *Circle:
    fmt.Printf("Type Circle %T\n", v)
case nil:
    fmt.Println("nil value: nothing to check?")
default:
    fmt.Printf("Unexpected type %T", v)
}

其中ins.(type)中的小寫type是固定的詞語。

如下是一個使用示例：

package main

import (
    "fmt"
)

// Shaper 接口類型
type Shaper interface {
    Area() float64
}

// Circle struct類型
type Circle struct {
    radius float64
}

// Circle類型實現Shaper中的方法Area()
func (c *Circle) Area() float64 {
    return 3.14 * c.radius * c.radius
}

// Square struct類型
type Square struct {
    length float64
}

// Square類型實現Shaper中的方法Area()
func (s Square) Area() float64 {
    return s.length * s.length
}

func main() {
    s1 := &Square{3.3}
    whichType(s1)

    s2 := Square{3.4}
    whichType(s2)

    c1 := new(Circle)
    c1.radius = 2.3
    whichType(c1)
}

func whichType(n Shaper) {
    switch v := n.(type) {
    case *Square:
        fmt.Printf("Type Square %T\n", v)
    case Square:
        fmt.Printf("Type Square %T\n", v)
    case *Circle:
        fmt.Printf("Type Circle %T\n", v)
    case nil:
        fmt.Println("nil value: nothing to check?")
    default:
        fmt.Printf("Unexpected type %T", v)
    }
}

上面的type-switch中，之因此沒有加上case Circle，是由於Circle只實現了指針類型的receiver，根據Method Set對接口的實現規則，只有指針類型的Circle示例纔算是實現了接口Shaper，因此將值類型的示例case Circle放進type-switch是錯誤的。