本文為轉載，原文地址：http://blog.go-china.org/22-type-assert

類型轉換在程序設計中都是不可避免的問題。當然有一些語言將這個過程給模糊了，大多數時候開發者并不需要去關注這方面的問題。但是golang中的類型匹配是很嚴格的，不同的類型之間通常需要手動轉換，編譯器不會代你去做這個事。我之所以說通常需要手動轉換，是因為interface類型作為一個特例，會有不同的處理方式。

golang中的所有類型都有自己的默認值，對此我做了個測試。

$GOPATH/src

—-typeassert_test

——–main.Go

main.go的代碼如下：

package main

import (
    "fmt"
)

type myStruct struct {
    name   bool
    userid int64
}

var structZero myStruct
var intZero int
var int32Zero int32
var int64Zero int64
var uintZero uint
var uint8Zero uint8
var uint32Zero uint32
var uint64Zero uint64
var byteZero byte
var boolZero bool
var float32Zero float32
var float64Zero float64
var stringZero string
var funcZero func(int) int
var byteArrayZero [5]byte
var boolArrayZero [5]bool
var byteSliceZero []byte
var boolSliceZero []bool
var mapZero map[string]bool
var interfaceZero interface{}
var chanZero chan int
var pointerZero *int

func main() {
    fmt.Println("structZero: ", structZero)
    fmt.Println("intZero: ", intZero)
    fmt.Println("int32Zero: ", int32Zero)
    fmt.Println("int64Zero: ", int64Zero)
    fmt.Println("uintZero: ", uintZero)
    fmt.Println("uint8Zero: ", uint8Zero)
    fmt.Println("uint32Zero: ", uint32Zero)
    fmt.Println("uint64Zero: ", uint64Zero)
    fmt.Println("byteZero: ", byteZero)
    fmt.Println("boolZero: ", boolZero)
    fmt.Println("float32Zero: ", float32Zero)
    fmt.Println("float64Zero: ", float64Zero)
    fmt.Println("stringZero: ", stringZero)
    fmt.Println("funcZero: ", funcZero)
    fmt.Println("funcZero == nil?", funcZero == nil)
    fmt.Println("byteArrayZero: ", byteArrayZero)
    fmt.Println("boolArrayZero: ", boolArrayZero)
    fmt.Println("byteSliceZero: ", byteSliceZero)
    fmt.Println("byteSliceZero's len?", len(byteSliceZero))
    fmt.Println("byteSliceZero's cap?", cap(byteSliceZero))
    fmt.Println("byteSliceZero == nil?", byteSliceZero == nil)
    fmt.Println("boolSliceZero: ", boolSliceZero)
    fmt.Println("mapZero: ", mapZero)
    fmt.Println("mapZero's len?", len(mapZero))
    fmt.Println("mapZero == nil?", mapZero == nil)
    fmt.Println("interfaceZero: ", interfaceZero)
    fmt.Println("interfaceZero == nil?", interfaceZero == nil)
    fmt.Println("chanZero: ", chanZero)
    fmt.Println("chanZero == nil?", chanZero == nil)
    fmt.Println("pointerZero: ", pointerZero)
    fmt.Println("pointerZero == nil?", pointerZero == nil)
}

$ cd $GOPATH/src/typeassert_test
$ go build
$ ./typeassert_test

您可以清楚的了解到各種類型的默認值。如bool的默認值是false，string的默認值是空串，byte的默認值是0，數組的默認就是這個數組成員類型的默認值所組成的數組等等。然而您或許會發現在上面的例子中：map、interface、pointer、slice、func、chan的默認值和nil是相等的。關于nil可以和什么樣的類型做相等比較，您只需要知道nil可以賦值給哪些類型變量，那么就可以和哪些類型變量做相等比較。官方對此有明確的說明：http://pkg.golang.org/pkg/builtin/#Type，也可以看我的另一篇文章：[golang: 詳解interface和nil](http://my.oschina.net/goal/blog/194233)。所以現在您應該知道nil只能賦值給指針、channel、func、interface、map或slice類型的變量。如果您用int類型的變量跟nil做相等比較，panic會找上您。

對于字面量的值，編譯器會有一個隱式轉換。看下面的例子：

package main

import (
    "fmt"
)

func main() {
    var myInt int32     = 5
    var myFloat float64 = 0
    fmt.Println(myInt)
    fmt.Println(myFloat)
}

對于myInt變量，它存儲的就是int32類型的5；對于myFloat變量，它存儲的是int64類型的0。或許您可能會寫出這樣的代碼，但確實不是必須這么做的：

package main

import (
    "fmt"
)

func main() {
    var myInt int32     = int32(5)
    var myFloat float64 = float64(0)
    fmt.Println(myInt)
    fmt.Println(myFloat)
}

在C中，大多數類型轉換都是可以隱式進行的，比如：

#include <stdio.h>

int main(int argc, char **argv)
{
        int uid  = 12345;
        long gid = uid;
        printf("uid=%d, gid=%d\n", uid, gid);
        return 0;
}

但是在golang中，您不能這么做。有個類似的例子：

package main

import (
    "fmt"
)

func main() {
    var uid int32 = 12345
    var gid int64 = int64(uid)
    fmt.Printf("uid=%d, gid=%d\n", uid, gid)
}

很顯然，將uid賦值給gid之前，需要將uid強制轉換成int64類型，否則會panic。golang中的類型區分靜態類型和底層類型。您可以用type關鍵字定義自己的類型，這樣做的好處是可以語義化自己的代碼，方便理解和閱讀。

package main

import (
    "fmt"
)

type MyInt32 int32

func main() {
    var uid int32   = 12345
    var gid MyInt32 = MyInt32(uid)
    fmt.Printf("uid=%d, gid=%d\n", uid, gid)
}

在上面的代碼中，定義了一個新的類型MyInt32。對于類型MyInt32來說，MyInt32是它的靜態類型，int32是它的底層類型。即使兩個類型的底層類型相同，在相互賦值時還是需要強制類型轉換的。可以用reflect包中的Kind方法來獲取相應類型的底層類型。

對于類型轉換的截斷問題，為了問題的簡單化，這里只考慮具有相同底層類型之間的類型轉換。小類型(這里指存儲空間)向大類型轉換時，通常都是安全的。下面是一個大類型向小類型轉換的示例：

package main

import (
    "fmt"
)

func main() {
    var gid int32 = 0x12345678
    var uid int8  = int8(gid)
    fmt.Printf("uid=0x%02x, gid=0x%02x\n", uid, gid)
}

在上面的代碼中，gid為int32類型，也即占4個字節空間(在內存中占有4個存儲單元)，因此這4個存儲單元的值分別是：0x12, 0x34, 0x56, 0x78。但事實不總是如此，這跟cpu架構有關。在內存中的存儲方式分為兩種：大端序和小端序。大端序的存儲方式是高位字節存儲在低地址上；小端序的存儲方式是高位字節存儲在高地址上。本人的機器是按小端序來存儲的，所以gid在我的內存上的存儲序列是這樣的：0x78, 0x56, 0x34, 0x12。如果您的機器是按大端序來存儲，則gid的存儲序列剛好反過來：0x12, 0x34, 0x56, 0x78。對于強制轉換后的uid，肯定是產生了截斷行為。因為uid只占1個字節，轉換后的結果必然會丟棄掉多余的3個字節。截斷的規則是：保留低地址上的數據，丟棄多余的高地址上的數據。來看下測試結果：

$ cd $GOPATH/src/typeassert_test
$ go build
$ ./typeassert_test
uid=0x78, gid=0x12345678

如果您的輸出結果是：

uid=0x12, gid=0x12345678

那么請不要驚訝，因為您的機器是屬于大端序存儲。

其實很容易根據上面所說的知識來判斷是屬于大端序或小端序：

package main

import (
    "fmt"
)

func IsBigEndian() bool {
    var i int32 = 0x12345678
    var b byte  = byte(i)
    if b == 0x12 {
        return true
    }

    return false
}

func main() {
    if IsBigEndian() {
        fmt.Println("大端序")
    } else {
        fmt.Println("小端序")
    }
}

接口的轉換遵循以下規則：

普通類型向接口類型的轉換是隱式的。

接口類型向普通類型轉換需要類型斷言。

普通類型向接口類型轉換的例子隨處可見，例如：

package main

import (
    "fmt"
)

func main() {
    var val interface{} = "hello"
    fmt.Println(val)
    val = []byte{'a', 'b', 'c'}
    fmt.Println(val)
}

正如您所預料的，”hello”作為string類型存儲在interface{}類型的變量val中，[]byte{‘a’, ‘b’, ‘c’}作為slice存儲在interface{}類型的變量val中。這個過程是隱式的，是編譯期確定的。

接口類型向普通類型轉換有兩種方式：Comma-ok斷言和switch測試。任何實現了接口I的類型都可以賦值給這個接口類型變量。由于interface{}包含了0個方法，所以任何類型都實現了interface{}接口，這就是為什么可以將任意類型值賦值給interface{}類型的變量，包括nil。還有一個要注意的就是接口的實現問題，*T包含了定義在T和*T上的所有方法，而T只包含定義在T上的方法。我們來看一個例子：

package main

import (
    "fmt"
)

// 演講者接口
type Speaker interface {
    // 說
    Say(string)
    // 聽
    Listen(string) string
    // 打斷、插嘴
    Interrupt(string)
}

// 王蘭講師
type WangLan struct {
    msg string
}

func (this *WangLan) Say(msg string) {
    fmt.Printf("王蘭說：%s\n", msg)
}

func (this *WangLan) Listen(msg string) string {
    this.msg = msg
    return msg
}

func (this *WangLan) Interrupt(msg string) {
    this.Say(msg)
}

// 江婁講師
type JiangLou struct {
    msg string
}

func (this *JiangLou) Say(msg string) {
    fmt.Printf("江婁說：%s\n", msg)
}

func (this *JiangLou) Listen(msg string) string {
    this.msg = msg
    return msg
}

func (this *JiangLou) Interrupt(msg string) {
    this.Say(msg)
}

func main() {
    wl := &WangLan{}
    jl := &JiangLou{}

    var person Speaker
    person = wl
    person.Say("Hello World!")
    person = jl
    person.Say("Good Luck!")
}

Speaker接口有兩個實現WangLan類型和JiangLou類型。但是具體到實例來說，變量wl和變量jl只有是對應實例的指針類型才真正能被Speaker接口變量所持有。這是因為WangLan類型和JiangLou類型所有對Speaker接口的實現都是在*T上。這就是上例中person能夠持有wl和jl的原因（不明白的可以看看我的其他相關博客）。

想象一下Java的泛型(很可惜golang不支持泛型)，java在支持泛型之前需要手動裝箱和拆箱。由于golang能將不同的類型存入到接口類型的變量中，使得問題變得更加復雜。所以有時候我們不得不面臨這樣一個問題：我們究竟往接口存入的是什么樣的類型？有沒有辦法反向查詢？答案是肯定的。

Comma-ok斷言的語法是：value, ok := element.(T)。element必須是接口類型的變量，T是普通類型。如果斷言失敗，ok為false，否則ok為true并且value為變量的值。來看個例子：

package main

import (
    "fmt"
)

type Html []interface{}

func main() {
    html := make(Html, 5)
    html[0] = "div"
    html[1] = "span"
    html[2] = []byte("script")
    html[3] = "style"
    html[4] = "head"
    for index, element := range html {
        if value, ok := element.(string); ok {
            fmt.Printf("html[%d] is a string and its value is %s\n", index, value)
        } else if value, ok := element.([]byte); ok {
            fmt.Printf("html[%d] is a []byte and its value is %s\n", index, string(value))
        }
    }
}

其實Comma-ok斷言還支持另一種簡化使用的方式：value := element.(T)。但這種方式不建議使用，因為一旦element.(T)斷言失敗，則會產生運行時錯誤。如：

package main

import (
    "fmt"
)

func main() {
    var val interface{} = "good"
    fmt.Println(val.(string))
    // fmt.Println(val.(int))
}

以上的代碼中被注釋的那一行會運行時錯誤。這是因為val實際存儲的是string類型，因此斷言失敗。

還有一種轉換方式是switch測試。既然稱之為switch測試，也就是說這種轉換方式只能出現在switch語句中。可以很輕松的將剛才用Comma-ok斷言的例子換成由switch測試來實現：

package main

import (
    "fmt"
)

type Html []interface{}

func main() {
    html := make(Html, 5)
    html[0] = "div"
    html[1] = "span"
    html[2] = []byte("script")
    html[3] = "style"
    html[4] = "head"
    for index, element := range html {
        switch value := element.(type) {
        case string:
            fmt.Printf("html[%d] is a string and its value is %s\n", index, value)
        case []byte:
            fmt.Printf("html[%d] is a []byte and its value is %s\n", index, string(value))
        case int:
            fmt.Printf("error type\n")
        default:
            fmt.Printf("unknown type\n")
        }
    }
}

$ cd $GOPATH/src/typeassert_test
$ go build
$ ./typeassert_test