淺談Go類型轉換之間的那些事

試着答一答這些問題

s[i]和(for _,v range)的v的區別是什麼

var s string = "AB"
fmt.Println(reflect.TypeOf(s[0]))
for _, v := range s {
   fmt.Println(reflect.TypeOf(v))
}

a.(),和 a(b) 的區別是什麼？

var v interface{} = 1
var s uint8 = 1

temp1 := int(s)
temp2 := v.(int)

fmt.Println(temp1,temp2)

Go的類型系統瞭解

Go的類型

Go語言是一門靜態編譯型語言，是一門強類型語言，Go語言中類型分爲兩種：命名類型(已定義類型)和未命名類型(組合類型)，我舉例說一下

1. 命名類型（已定義類型）

uint8(byte) uint16 uint32 uint64 int int8 int16 int32(rune) int64 bool string
float32 float64 complex64 complex128

上面舉例類型歸爲三大類：，數值類型，字符串類型， 布爾值類型，咱們使用type定義的任何類型也被稱爲命名類型，以下

//也是命名類型
type MyBool bool

1. 未命名類型 (組合類型)

slice map chan function interface struct pointer

上面舉例的類型有容器類型，函數類型，指針類型，結構體類型，通道類型，接口類型

自定義類型和底層類型

Go容許經過type關鍵字定義一個類型
Go的每個類型都一個底層類型，類型的底層類型有以下規律

1. 每個命名類型的底層類型都是本身
2. 每個組合類型的底層類型都是本身
3. 在一個類型的聲明中，新聲明的類型和原類型的底層類型是共享的

以下代碼,請問這段代碼可以編譯成功嗎？爲何？首先這段代碼是編譯失敗的，i的類型是MyInt，j的類型是int，雖然說她們的底層類型都是int，但不能相互賦值，也就說明命名類型間是不能相互賦值的，即使是低限制往高限制賦值，好比 int32 賦給 int64也是編譯失敗的

type MyInt int
func CustomType() {
   var i MyInt = 2
   var j int = 1
   j = i
   i = j
   fmt.Println(i == j)
}

下面這段代碼會打印這兩個變量的基本類型和底層類型，

//輸出MyInt int
fmt.Println(reflect.TypeOf(i), reflect.TypeOf(j))
//輸出int int
fmt.Println(reflect.TypeOf(i).Kind(), reflect.TypeOf(j).Kind())

咱們再來看一個Demo,下面這段代碼編譯會報錯嗎，若是把int32改爲int64呢？答案是編譯報錯，改爲int64也會編譯報錯，只有j和int32同時改爲i和int64,纔會編譯成功。由於這時m和n的底層類型是徹底相同的。

type MyM struct {
   i int64
}
type MyN struct {
   j int32
}
func TestStruct() {
   n := MyN{j: 10}
   var m MyM
   m = MyM(n)
  fmt.Println(n,m)
}

如何追蹤朔源一個類型的的底層類型

以下代碼，說說這些類型的底層類型是什麼？

type MyInt int
type I MyInt
type Ints []int
type MyInts []MyInt
type M map[string]string
type CustomM M

MyInt的底層類型是int
I的底層類型時int
Ints的底層類型是[]int
MyInts的底層類型是slice
M的底層類是map
CustomM的底層類是map

規律就是直到找到的一個內置類型（Go內置的類型）或者未命名類型（組合類型）結束，這個類型就是當前類型的底層類型

怎麼經過代碼獲取一個類型的底層類型呢?經過下面代碼獲取

reflect.TypeOf(variable).Kind()

類型別名

什麼是類型別名呢？Go中有兩個類型別名 byte，對應的真實類型是uint8，rune,對應的真實類型是int32，咱們能夠源代碼中這兩個的定義以下

// byte is an alias for uint8 and is equivalent to uint8 in all ways. It is
// used, by convention, to distinguish byte values from 8-bit unsigned
// integer values.
type byte = uint8

// rune is an alias for int32 and is equivalent to int32 in all ways. It is
// used, by convention, to distinguish character values from integer values.
type rune = int32

從這個就能就能解決最開始的第一個問題，s[index]取得是字符串轉換成字節後的某一個字節，而range指的是循環字符串s的每個字符(range會隱式的unicode解碼)， 但字符區分字母和漢字，一個字母佔用一個字節，一個漢字可不是了，看以下代碼，你能夠獲取byte和rune的底層類型

var r rune = 'c'
var b byte = 1
fmt.Println(reflect.TypeOf(r).Kind()) //int32
fmt.Println(reflect.TypeOf(b).Kind()) //uint8

如何定義一個類型別名呢？其實很簡單，知道怎麼定義一個類型，那麼定義一個類型別名就很簡單了，參考上面的byte和rune，以下咱們爲int64定義一個別名(從Go1.9開始支持)，類型別名是能夠被聲明在函數體內的

//相比定義一個類型多了一個=號
type alaisInt64 = int64

類型轉換和斷言

類型轉換是用來在類型不一樣但相互兼容的類型之間的相互轉換的方式，若是不兼容，則沒法相互轉換，編譯會報錯,一般寫法是 a(b),把b轉換成a

類型斷言是在接口之間進行，本質也是類型轉換，寫法是a.(b),含義是把a轉換成b

以下代碼，作一些錯誤的和正確的示範

//這個轉換時類型不一樣，也不兼容，因此編譯報錯
s := "ab"
i := int(s)

//這個轉換類型不一樣，但兼容，因此OK
var j int8 = 1
m := int(j)

//這個轉換是失敗的，系統會檢測到類型不匹配，直接panic
var k interface{} = "s"
l := k.(int)
//但咱們能夠經過一個參數來判斷,只有f爲true時，纔會轉換成功
l,f := k.(int)
//這個轉換是成功的
p,f := k.(string)

類型轉換的實踐，勤加練習才能理解

數字類型之間轉換

從低位轉高位沒有什麼問題，從高位轉低位時(會丟失精度)，int64轉int8，這個轉換的過程以下：
128的二進制：.........00000000_10000000
由於是從int64轉int8，因此截取128的後八位 ：10000000
此時最高位是1，表示這是一個負數，此時結果是就是：-128

//這個轉換沒有任何問題，都OK
var i int8 = 123
var j int16 = int16(i)
//這個轉換會丟失精度，從高位轉低位
var m int64 = 128
var n int8 = int8(m) //n的結果是-128，由於int8能表達的最大值是127，最小值是-128，

字符串，字節，數字，字符互相轉換

var s1,s2 string = "AbcD","1234"
//轉字節
bs1 := []byte(s1); bs2 := []byte(s2)

//字節數組轉字符串
s11 := string(bs1); s22 := string(bs2)
//單個字節轉字符串
ss := string(bs1[0])
fmt.Println(s11, s22, ss)

//s2轉數字 ,err 表示是否能轉換成功，好比s1就會轉換失敗
i, err := strconv.Atoi(s2)
//數字轉字符串
s := strconv.Itoa(i)

//字符串轉字符數組
runes := []rune(s1)

//字符數組轉字符串
ss1 := string(runes)
//單個字符轉字符串
ss2 := strconv.QuoteRune(runes[0])

//字符轉字節
bss := make([]byte, 0)
bss = strconv.AppendQuoteRune(bss, runes[0])
fmt.Println(err, s, ss1, ss2, runes[0], bss, string(bss))
//除開rune和byte底層的類型的區別，在使用上，
//rune能處理一切的字符，而byte僅僅侷限在ascii

//整形轉字節
x := int32(68)
bytesBuffer := bytes.NewBuffer([]byte{})
binary.Write(bytesBuffer, binary.BigEndian, x)
//字節轉整形
var y int32
binary.Read(bytesBuffer, binary.BigEndian, &y)

接口到具體類型的轉換

//由接口類型轉換爲具體的類型
var i interface{} = 1
t, f := i.(int)
if f { //轉換成功
   fmt.Println(t)
} else {//轉換失敗
   fmt.Println(reflect.TypeOf(i).Kind(), reflect.TypeOf(i))
}

歡迎關注公衆號，閱讀更多精彩文章