01 介紹

Go 語言是強類型編程語言，一些使用弱類型編程語言的讀者朋友們在初學(xué) Go 語言時，多多少少都會不太適應(yīng) Go 語言的類型。

Go 語言變量類型包含基礎(chǔ)類型和復(fù)合類型，類型轉(zhuǎn)換和類型斷言一般是對基礎(chǔ)類型的處理，基礎(chǔ)類型包含整數(shù)、浮點數(shù)、布爾和字符串。

其中整數(shù)類型又稱為整型，分為有符合和無符號，各自又包含不同大小，8位、16位、32位和64位，其中 int32 和 uint8 的類型別名分別是 rune和 byte。

浮點數(shù)類型分為 float32 和 float64，為了避免精度丟失，一般我們選擇使用 float64，float32 和 float64 之間可以直接轉(zhuǎn)換，整型和浮點數(shù)類型之間也可以直接轉(zhuǎn)換，需要注意丟失精度的問題。

布爾類型的值只有兩個，分別是 true 和 false，類型零值為 false。需要注意的是它無法像弱類型編程語言可以隱式轉(zhuǎn)換為 1 和 0。

字符串類型是一組使用雙引號引起來的字節(jié)序列，它可以包含任意數(shù)據(jù)。需要注意的是它不可以改變，因為多個字符串可以共享同一塊內(nèi)存空間。

本文我們介紹 Go 語言的類型轉(zhuǎn)換和類型斷言。

02 類型轉(zhuǎn)換

我們在項目開發(fā)時，可能會遇到一些需要類型轉(zhuǎn)換的場景，比如我們使用 Go 語言開發(fā) Api 接口。

客戶端（調(diào)用方）在請求我們使用 Go 語言開發(fā)的 Api 接口時，雖然會按照我們預(yù)先協(xié)商的參數(shù)類型，但是隨著項目的不斷迭代，可能以前定義的變量類型需要修改。

因為 Go 語言是強類型語言，不支持類型隱式轉(zhuǎn)換，我們就需要顯式轉(zhuǎn)換變量的類型。

Go 語言類型轉(zhuǎn)換的方式：

強制轉(zhuǎn)換

整數(shù)類型之間可以強制轉(zhuǎn)換，代碼如下：

func main(){
    var a int64
    a = 1
    fmt.Printf("%T\t%d\n", a, a)
    var b int8
    b = int8(a)
    fmt.Printf("%T\t%d\n", b, b)
}

閱讀上面這段代碼，我們定義 int64 類型的變量 a，使用 <類型>(<數(shù)值>) 的格式，直接把變量 a 的由 int64 轉(zhuǎn)換為 int8 的變量 b。

浮點數(shù)類型之間，浮點數(shù)和整型之間，也可以強制轉(zhuǎn)換，代碼如下：

func main(){
    var a float64
    a = 3.1415926
    fmt.Printf("%T\t%f\n", a, a)
    var b float32
    b = float32(a)
    fmt.Printf("%T\t%f\n", b, b)
    var c int64
    c = int64(b)
    fmt.Printf("%T\t%d\n", c, c)
}

閱讀上面這段代碼，我們定義 float64 類型的變量 a，使用 <類型>(<數(shù)值>) 的格式，直接把變量 a 由 float64 轉(zhuǎn)換為 float32 的變量 b，然后變量 b 由 float32 轉(zhuǎn)換為 int64 的變量 c。需要注意丟失精度的問題。

布爾類型 bool，它的值只有兩個，分別是 true 和 false，它沒有其它類型可以強制轉(zhuǎn)換，不過可以使用標(biāo)準(zhǔn)庫或三方庫對布爾類型進(jìn)行類型轉(zhuǎn)換。

字符串類型是一組使用雙引號引起來的字節(jié)序列，所以 string 和 []byte 之間可以強制轉(zhuǎn)換，代碼如下：

func main(){
    var a string
    a = "golang"
    fmt.Printf("%T\t%s\n", a, a)
    var b []byte
    b = []byte(a)
    fmt.Printf("%T\t%d\n", b, b)
}

閱讀上面這段代碼，我們定義 string 類型的變量 a，使用 <類型>(<數(shù)值>) 的格式，直接把變量 a 由 string 轉(zhuǎn)換為 []byte 的變量 b，反之亦然。

使用標(biāo)準(zhǔn)庫或三方庫

無法強制轉(zhuǎn)換的類型，可以使用標(biāo)準(zhǔn)庫或三方庫，比如布爾類型，代碼如下：

func main(){
    var a bool
    a = true
    fmt.Printf("%T\t%t\n", a, a)
    var b string
    b = strconv.FormatBool(a)
    fmt.Printf("%T\t%s\n", b, b)
}

閱讀上面這段代碼，我們定義 bool 類型的變量 a，使用 <類型>(<數(shù)值>) 的格式，使用標(biāo)準(zhǔn)庫 strconv 的方法把變量 a 由 bool 轉(zhuǎn)換為 string 的變量 b。

除了標(biāo)準(zhǔn)庫 strconv[1] 之外，標(biāo)準(zhǔn)庫 fmt[2] 也提供了類型轉(zhuǎn)換的方法；還有一些三方庫，比如 cast[3]。限于篇幅，此處不再詳細(xì)贅述，感興趣的讀者朋友們可以閱讀相關(guān)文檔了解更多。

03 類型斷言

我們在項目開發(fā)時，可能想要定義參數(shù)的類型為通用類型，比如我們使用 Go 語言開發(fā) Api 接口。

我們想要盡量適配客戶端（調(diào)用方）傳參使用不同類型，比如調(diào)用方是使用弱類型編程語言的場景。

我們可以定義變量類型的空接口類型 interface{}，然后使用類型斷言，獲取傳參的實際類型，按需處理為我們想要的類型。

示例代碼：

func main(){
    var id interface{}
    id = 1 // 參數(shù) id 接收到的值為整型
    fmt.Printf("%T\t%v\n", id, id)
    // 需要使用字符串類型的變量 id 賦值給字符串類型的變量 uid
    var uid string
    value, ok := id.(string)
    if ok {
        uid = value
    }
    fmt.Printf("%T\t%v\n", uid, uid)
}

閱讀上面這段代碼，我們定義 interface{} 空接口類型的變量 id，作為接收請求參數(shù)，實際需要使用字符串類型的數(shù)據(jù)，我們使用類型斷言檢查變量 id 的值是否是字符串類型，是字符串類型則賦值給變量 uid。

需要注意的是，我們在使用類型斷言時，最好使用 ok-idiom 模式，避免引發(fā) panic。

此外，還有 switch case 方式的類型斷言，也稱為類型選擇?？梢蕴幚矶喾N類型，代碼如下：

func main() {
    var id interface{}
    id = 1 // 參數(shù) id 接收到的值為整型
    fmt.Printf("0-%T\t%v\n", id, id)
    // 需要使用字符串類型的變量 id 賦值給字符串類型的變量 uid
    var uid string
    switch val := id.(type) {
    case string:
     uid = val
     fmt.Printf("1-%T\t%v\n", uid, uid)
    case int:
     uid = strconv.Itoa(val)
     fmt.Printf("2-%T\t%v\n", uid, uid)
    default:
     fmt.Printf("3-%T\t%v\n", uid, uid)
    }
}

閱讀上面這段代碼，我們使用 switch case 方式的類型斷言參數(shù) id，如果參數(shù)的值是我們需要的類型，則直接使用，反之，則類型轉(zhuǎn)換之后再使用。

細(xì)心的讀者朋友們可能發(fā)現(xiàn)該方式的類型斷言格式有所不同，小括號中的數(shù)據(jù)類型改為 type。

需要注意的是，使用 switch case 方式的類型斷言，即便省略 default，也不會因為不是 ok-idiom 模式的類型斷言而引發(fā) panic。

04 總結(jié)

本文我們介紹 Go 語言中讓之前一直使用弱類型編程語言的讀者朋友們迷惑的類型轉(zhuǎn)換和類型斷言。

讀完本文，大家至少可以區(qū)分類型轉(zhuǎn)換和類型斷言的區(qū)別，和了解各自的使用場景。