01 介紹

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

Go 語言變量類型包含基礎類型和復合類型，類型轉換和類型斷言一般是對基礎類型的處理，基礎類型包含整數、浮點數、布爾和字符串。

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

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

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

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

本文我們介紹 Go 語言的類型轉換和類型斷言。

02 類型轉換

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

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

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

Go 語言類型轉換的方式：

強制轉換

整數類型之間可以強制轉換，代碼如下：

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，使用 <類型>(<數值>) 的格式，直接把變量 a 的由 int64 轉換為 int8 的變量 b。

浮點數類型之間，浮點數和整型之間，也可以強制轉換，代碼如下：

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，使用 <類型>(<數值>) 的格式，直接把變量 a 由 float64 轉換為 float32 的變量 b，然后變量 b 由 float32 轉換為 int64 的變量 c。需要注意丟失精度的問題。

布爾類型 bool，它的值只有兩個，分別是 true 和 false，它沒有其它類型可以強制轉換，不過可以使用標準庫或三方庫對布爾類型進行類型轉換。

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

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，使用 <類型>(<數值>) 的格式，直接把變量 a 由 string 轉換為 []byte 的變量 b，反之亦然。

使用標準庫或三方庫

無法強制轉換的類型，可以使用標準庫或三方庫，比如布爾類型，代碼如下：

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，使用 <類型>(<數值>) 的格式，使用標準庫 strconv 的方法把變量 a 由 bool 轉換為 string 的變量 b。

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

03 類型斷言

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

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

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

示例代碼：

func main(){
    var id interface{}
    id = 1 // 參數 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，作為接收請求參數，實際需要使用字符串類型的數據，我們使用類型斷言檢查變量 id 的值是否是字符串類型，是字符串類型則賦值給變量 uid。

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

此外，還有 switch case 方式的類型斷言，也稱為類型選擇。可以處理多種類型，代碼如下：

func main() {
    var id interface{}
    id = 1 // 參數 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 方式的類型斷言參數 id，如果參數的值是我們需要的類型，則直接使用，反之，則類型轉換之后再使用。

細心的讀者朋友們可能發現該方式的類型斷言格式有所不同，小括號中的數據類型改為 type。

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

04 總結

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

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