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

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

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

$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

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

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

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。或許您可能會寫出這樣的代碼，但確實(shí)不是必須這么做的：

package main

import (
    "fmt"
)

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

在C中，大多數(shù)類型轉(zhuǎn)換都是可以隱式進(jìn)行的，比如：

#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強(qiáng)制轉(zhuǎn)換成int64類型，否則會panic。golang中的類型區(qū)分靜態(tài)類型和底層類型。您可以用type關(guān)鍵字定義自己的類型，這樣做的好處是可以語義化自己的代碼，方便理解和閱讀。

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是它的靜態(tài)類型，int32是它的底層類型。即使兩個類型的底層類型相同，在相互賦值時還是需要強(qiáng)制類型轉(zhuǎn)換的。可以用reflect包中的Kind方法來獲取相應(yīng)類型的底層類型。

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

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個字節(jié)空間(在內(nèi)存中占有4個存儲單元)，因此這4個存儲單元的值分別是：0x12, 0x34, 0x56, 0x78。但事實(shí)不總是如此，這跟cpu架構(gòu)有關(guān)。在內(nèi)存中的存儲方式分為兩種：大端序和小端序。大端序的存儲方式是高位字節(jié)存儲在低地址上；小端序的存儲方式是高位字節(jié)存儲在高地址上。本人的機(jī)器是按小端序來存儲的，所以gid在我的內(nèi)存上的存儲序列是這樣的：0x78, 0x56, 0x34, 0x12。如果您的機(jī)器是按大端序來存儲，則gid的存儲序列剛好反過來：0x12, 0x34, 0x56, 0x78。對于強(qiáng)制轉(zhuǎn)換后的uid，肯定是產(chǎn)生了截斷行為。因?yàn)閡id只占1個字節(jié)，轉(zhuǎn)換后的結(jié)果必然會丟棄掉多余的3個字節(jié)。截斷的規(guī)則是：保留低地址上的數(shù)據(jù)，丟棄多余的高地址上的數(shù)據(jù)。來看下測試結(jié)果：

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

如果您的輸出結(jié)果是：

uid=0x12, gid=0x12345678

那么請不要驚訝，因?yàn)槟臋C(jī)器是屬于大端序存儲。

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

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("小端序")
    }
}

接口的轉(zhuǎn)換遵循以下規(guī)則：

普通類型向接口類型的轉(zhuǎn)換是隱式的。

接口類型向普通類型轉(zhuǎn)換需要類型斷言。

普通類型向接口類型轉(zhuǎn)換的例子隨處可見，例如：

package main

import (
    "fmt"
)

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

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

接口類型向普通類型轉(zhuǎn)換有兩種方式：Comma-ok斷言和switch測試。任何實(shí)現(xiàn)了接口I的類型都可以賦值給這個接口類型變量。由于interface{}包含了0個方法，所以任何類型都實(shí)現(xiàn)了interface{}接口，這就是為什么可以將任意類型值賦值給interface{}類型的變量，包括nil。還有一個要注意的就是接口的實(shí)現(xiàn)問題，*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接口有兩個實(shí)現(xiàn)WangLan類型和JiangLou類型。但是具體到實(shí)例來說，變量wl和變量jl只有是對應(yīng)實(shí)例的指針類型才真正能被Speaker接口變量所持有。這是因?yàn)閃angLan類型和JiangLou類型所有對Speaker接口的實(shí)現(xiàn)都是在*T上。這就是上例中person能夠持有wl和jl的原因（不明白的可以看看我的其他相關(guān)博客）。

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

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))
        }
    }
}

其實(shí)Comma-ok斷言還支持另一種簡化使用的方式：value := element.(T)。但這種方式不建議使用，因?yàn)橐坏〆lement.(T)斷言失敗，則會產(chǎn)生運(yùn)行時錯誤。如：

package main

import (
    "fmt"
)

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

以上的代碼中被注釋的那一行會運(yùn)行時錯誤。這是因?yàn)関al實(shí)際存儲的是string類型，因此斷言失敗。

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

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