4.類型轉換 · golang

零值變量在定義時沒有明確的初始化時會賦值為零值。零值是： ~~~ 數值類型為 0 ，布爾類型為 false ，字符串為 "" （空字符串）。 ~~~ Golang 不支持隱式類型轉換，即便是從窄向寬轉換也不行。 ~~~ package main var b byte = 100 // var n int = b // ./main.go:5:5: cannot use b (type byte) as type int in assignment var n int = int(b) // 顯式轉換 func main() {} ~~~ 同樣不能將其他類型當 bool 值使用。 ~~~ package main func main() { a := 100 if a { // Error: non-bool a (type int) used as if condition println("true") } } ~~~ 類型轉換類型轉換用于將一種數據類型的變量轉換為另外一種類型的變量。Go 語言類型轉換基本格式如下：表達式 T(v) 將值 v 轉換為類型 T 。 type_name(expression) type_name 為類型，expression 為表達式。實例將整型轉化為浮點型，并計算結果，將結果賦值給浮點型變量： ~~~ package main import "fmt" func main() { var sum int = 17 var count int = 5 var mean float32 mean = float32(sum) / float32(count) fmt.Printf("mean 的值為: %f\n", mean) } ~~~ 輸出結果： ~~~ mean 的值為: 3.400000 ~~~ 一些關于數值的轉換： ~~~ package main import ( "fmt" "reflect" ) func main() { var i int = 42 fmt.Printf("i value is : %v , type is : %v \n", i, reflect.TypeOf(i)) var f float64 = float64(i) fmt.Printf("f value is : %v , type is : %v \n", f, reflect.TypeOf(f)) var u uint = uint(f) fmt.Printf("u value is : %v , type is : %v \n", u, reflect.TypeOf(u)) } ~~~ 輸出結果： ~~~ i value is : 42 , type is : int f value is : 42 , type is : float64 u value is : 42 , type is : uint ~~~ 或者，更加簡單的形式： ~~~ package main import ( "fmt" "reflect" ) func main() { i := 42 f := float64(i) u := uint(f) fmt.Printf("i value is : %v , type is : %v \n", i, reflect.TypeOf(i)) fmt.Printf("f value is : %v , type is : %v \n", f, reflect.TypeOf(f)) fmt.Printf("u value is : %v , type is : %v \n", u, reflect.TypeOf(u)) } ~~~ 輸出結果： ~~~ i value is : 42 , type is : int f value is : 42 , type is : float64 u value is : 42 , type is : uint ~~~ 類型推導在定義一個變量卻并不顯式指定其類型時（使用 := 語法或者 var = 表達式語法）【全局變量不適用】，變量的類型由（等號）右側的值推導得出。當右值定義了類型時，新變量的類型與其相同： ~~~ package main import ( "fmt" "reflect" ) func main() { var i int j := i // j 也是一個 int fmt.Printf("i type is : %v\n", reflect.TypeOf(i)) fmt.Printf("j type is : %v\n", reflect.TypeOf(j)) } ~~~ 輸出結果： ~~~ i type is : int j type is : int ~~~ 但是當右邊包含了未指名類型的數字常量時，新的變量就可能是 int 、 float64 或 complex128 。 ~~~ package main import ( "fmt" "reflect" ) func main() { i := 42 f := 3.142 g := 0.867 + 0.5i fmt.Printf("i type is : %v\n", reflect.TypeOf(i)) fmt.Printf("f type is : %v\n", reflect.TypeOf(f)) fmt.Printf("g type is : %v\n", reflect.TypeOf(g)) } ~~~ 輸出結果： ~~~ i type is : int f type is : float64 g type is : complex128 ~~~ Go各種類型轉換及函數的高級用法字符串轉整形 ~~~ 將字符串轉換為 int 類型 strconv.ParseInt(str,base,bitSize) str：要轉換的字符串 base：進位制（2 進制到 36 進制） bitSize：指定整數類型（0:int、8:int8、16:int16、32:int32、64:int64）返回轉換后的結果和轉換時遇到的錯誤如果 base 為 0，則根據字符串的前綴判斷進位制（0x:16，0:8，其它:10） ParseUint 功能同 ParseInt 一樣，只不過返回 uint 類型整數 ~~~ Atoi 相當于 ParseInt(s, 10, 0) 通常使用這個函數，而不使用 ParseInt 該方法的源碼是： ~~~ // Itoa is shorthand for FormatInt(i, 10). func Itoa(i int) string { return FormatInt(int64(i), 10) } 可以看出是FormatInt方法的簡單實現。 ~~~ ~~~ package main import ( "fmt" "reflect" "strconv" ) func main() { i, ok := strconv.ParseInt("1000", 10, 0) if ok == nil { fmt.Printf("ParseInt , i is %v , type is %v\n", i, reflect.TypeOf(i)) } ui, ok := strconv.ParseUint("100", 10, 0) if ok == nil { fmt.Printf("ParseUint , ui is %v , type is %v\n", ui, reflect.TypeOf(i)) } oi, ok := strconv.Atoi("100") if ok == nil { fmt.Printf("Atoi , oi is %v , type is %v\n", oi, reflect.TypeOf(i)) } } ~~~ 輸出結果： ~~~ ParseInt , i is 1000 , type is int64 ParseUint , ui is 100 , type is int64 Atoi , oi is 100 , type is int64 ~~~ 整形轉字符串 ~~~ FormatInt int 型整數 i 轉換為字符串形式 strconv.FormatInt.(i,base) FormatUint 將 uint 型整數 i 轉換為字符串形式 strconv.FormatUint.(i,base) base：進位制（2 進制到 36 進制）大于 10 進制的數，返回值使用小寫字母 ‘a’ 到 ‘z’ Itoa 相當于 FormatInt(i, 10) ~~~ ~~~ package main import ( "fmt" "reflect" "strconv" ) func main() { var i int64 i = 0x100 str := strconv.FormatInt(i, 10) // FormatInt第二個參數表示進制，10表示十進制。 fmt.Println(str) fmt.Println(reflect.TypeOf(str)) } ~~~ 輸出結果： ~~~ 256 string ~~~ AppendInt 將 int 型整數 i 轉換為字符串形式，并追加到 []byte 的尾部 strconv.AppendInt([]byte, i, base) AppendUint 將 uint 型整數 i 轉換為字符串形式，并追加到 dst 的尾部 strconv.AppendUint([]byte, i, base) i：要轉換的字符串 base：進位制返回追加后的 []byte ~~~ package main import ( "fmt" "strconv" ) func main() { b := make([]byte, 0) b = strconv.AppendInt(b, -2048, 16) fmt.Printf("%s\n", b) } ~~~ 輸出結果： ~~~ -800 ~~~ 字節轉32位整形 ~~~ package main import ( "bytes" "encoding/binary" "fmt" ) func main() { b := []byte{0x00, 0x00, 0x03, 0xe8} bytesBuffer := bytes.NewBuffer(b) var x int32 binary.Read(bytesBuffer, binary.BigEndian, &x) fmt.Println(x) } // 其中binary.BigEndian表示字節序，相應的還有little endian。通俗的說法叫大端、小端。 ~~~ 輸出結果： ~~~ 1000 ~~~ 32位整形轉字節 ~~~ package main import ( "bytes" "encoding/binary" "fmt" "reflect" ) func main() { var x int32 x = 106 bytesBuffer := bytes.NewBuffer([]byte{}) binary.Write(bytesBuffer, binary.BigEndian, x) b := bytesBuffer.Bytes() fmt.Println(b) fmt.Println(reflect.TypeOf(b)) } ~~~ 輸出結果： ~~~ [0 0 0 106] []uint8 ~~~ 字節轉字符串 ~~~ package main import ( "fmt" "reflect" ) func main() { b := []byte{97, 98, 99, 100} str := string(b) fmt.Println(str) fmt.Println(reflect.TypeOf(str)) } ~~~ 輸出結果： ~~~ abcd string ~~~ 字符串轉字節 ~~~ package main import ( "fmt" ) func main() { str := "abcd" b := []byte(str) fmt.Println(b) } ~~~ 輸出結果： ~~~ [97 98 99 100] ~~~ 字符串轉布爾值 ParseBool ~~~ package main import ( "fmt" "strconv" ) func main() { b, err := strconv.ParseBool("1") fmt.Printf("string 1 轉 bool ：%v , err is : %v\n", b, err) b, err = strconv.ParseBool("t") fmt.Printf("string t 轉 bool ：%v , err is : %v\n", b, err) b, err = strconv.ParseBool("T") fmt.Printf("string T 轉 bool ：%v , err is : %v\n", b, err) b, err = strconv.ParseBool("true") fmt.Printf("string true 轉 bool ：%v , err is : %v\n", b, err) b, err = strconv.ParseBool("True") fmt.Printf("string True 轉 bool ：%v , err is : %v\n", b, err) b, err = strconv.ParseBool("TRUE") fmt.Printf("string TRUE 轉 bool ：%v , err is : %v\n", b, err) b, err = strconv.ParseBool("TRue") fmt.Printf("string TRue 轉 bool ：%v , err is : %v\n", b, err) b, err = strconv.ParseBool("") fmt.Printf("string '' 轉 bool ：%v , err is : %v\n", b, err) b, err = strconv.ParseBool("0") fmt.Printf("string 0 轉 bool ：%v , err is : %v\n", b, err) b, err = strconv.ParseBool("f") fmt.Printf("string f 轉 bool ：%v , err is : %v\n", b, err) b, err = strconv.ParseBool("F") fmt.Printf("string F 轉 bool ：%v , err is : %v\n", b, err) b, err = strconv.ParseBool("false") fmt.Printf("string false 轉 bool ：%v , err is : %v\n", b, err) b, err = strconv.ParseBool("False") fmt.Printf("string False 轉 bool ：%v , err is : %v\n", b, err) b, err = strconv.ParseBool("FALSE") fmt.Printf("string FALSE 轉 bool ：%v , err is : %v\n", b, err) b, err = strconv.ParseBool("FALse") fmt.Printf("string FALse 轉 bool ：%v , err is : %v\n", b, err) b, err = strconv.ParseBool("abc") fmt.Printf("string abc 轉 bool ：%v , err is : %v\n", b, err) } ~~~ 輸出結果： ~~~ string 1 轉 bool ：true , err is : <nil> string t 轉 bool ：true , err is : <nil> string T 轉 bool ：true , err is : <nil> string true 轉 bool ：true , err is : <nil> string True 轉 bool ：true , err is : <nil> string TRUE 轉 bool ：true , err is : <nil> string TRue 轉 bool ：false , err is : strconv.ParseBool: parsing "TRue": invalid syntax string '' 轉 bool ：false , err is : strconv.ParseBool: parsing "": invalid syntax string 0 轉 bool ：false , err is : <nil> string f 轉 bool ：false , err is : <nil> string F 轉 bool ：false , err is : <nil> string false 轉 bool ：false , err is : <nil> string False 轉 bool ：false , err is : <nil> string FALSE 轉 bool ：false , err is : <nil> string FALse 轉 bool ：false , err is : strconv.ParseBool: parsing "FALse": invalid syntax string abc 轉 bool ：false , err is : strconv.ParseBool: parsing "abc": invalid syntax ParseBool 將字符串轉換為布爾值它接受真值：1, t, T, TRUE, true, True 它接受假值：0, f, F, FALSE, false, False. 其它任何值都返回一個錯誤 ~~~ 布爾值轉換為字符串 FormatBool ~~~ package main import ( "fmt" "reflect" "strconv" ) func main() { t := strconv.FormatBool(true) f := strconv.FormatBool(false) fmt.Printf("t is %v , t type is %v\n", t, reflect.TypeOf(t)) fmt.Printf("f is %v , f type is %v\n", f, reflect.TypeOf(f)) } ~~~ 輸出結果： ~~~ t is true , t type is string f is false , f type is string ~~~ AppendBool 將布爾類型轉換為字符串然后將結果追加到 []byte 的尾部，返回追加后的 []byte ~~~ package main import ( "fmt" "strconv" ) func main() { rst := []byte{} fmt.Printf("[]byte{} is %s\n", rst) rst = strconv.AppendBool(rst, true) fmt.Printf("appended true []byte{} is %s\n", rst) rst = strconv.AppendBool(rst, false) fmt.Printf("appended false []byte{} is %s\n", rst) } ~~~ 輸出結果： ~~~ []byte{} is appended true []byte{} is true appended false []byte{} is truefalse ~~~ 將字符串轉換為浮點數 strconv.ParseFloat(str,bitSize) str：要轉換的字符串 bitSize：指定浮點類型（32:float32、64:float64）如果 str 是合法的格式，而且接近一個浮點值，則返回浮點數的四舍五入值（依據 IEEE754 的四舍五入標準）如果 str 不是合法的格式，則返回“語法錯誤” 如果轉換結果超出 bitSize 范圍，則返回“超出范圍” ~~~ package main import ( "fmt" "strconv" ) func main() { s := "0.12345678901234567890" f, err := strconv.ParseFloat(s, 32) fmt.Println(f, err) fmt.Println(float32(f)) fmt.Println("-----") f, err = strconv.ParseFloat(s, 64) fmt.Println(f, err) fmt.Println(float64(f)) fmt.Println("-----") str := "abcd" f, err = strconv.ParseFloat(str, 32) fmt.Println(f, err) } ~~~ 輸出結果： ~~~ 0.12345679104328156 <nil> 0.12345679 ----- 0.12345678901234568 <nil> 0.12345678901234568 ----- 0 strconv.ParseFloat: parsing "abcd": invalid syntax ~~~ 將浮點數轉換為字符串值 ~~~ strconv.FormatFloat(f,fmt,prec,bitSize) f：要轉換的浮點數 fmt：格式標記（b、e、E、,f、g、G） prec：精度（數字部分的長度，不包括指數部分） bitSize：指定浮點類型（32:float32、64:float64）格式標記： ‘b’ (-ddddp±ddd，二進制指數) ‘e’ (-d.dddde±dd，十進制指數) ‘E’ (-d.ddddE±dd，十進制指數) ‘f’ (-ddd.dddd，沒有指數) ‘g’ (‘e’:大指數，’f’:其它情況) ‘G’ (‘E’:大指數，’f’:其它情況) 如果格式標記為 ‘e’，’E’和’f’，則 prec 表示小數點后的數字位數如果格式標記為 ‘g’，’G’，則 prec 表示總的數字位數（整數部分+小數部分） ~~~ ~~~ package main import ( "fmt" "strconv" ) func main() { f := 100.12345678901234567890123456789 fmt.Println(strconv.FormatFloat(f, 'b', 5, 32)) fmt.Println(strconv.FormatFloat(f, 'e', 5, 32)) fmt.Println(strconv.FormatFloat(f, 'E', 5, 32)) fmt.Println(strconv.FormatFloat(f, 'f', 5, 32)) fmt.Println(strconv.FormatFloat(f, 'g', 5, 32)) fmt.Println(strconv.FormatFloat(f, 'G', 5, 32)) fmt.Println(strconv.FormatFloat(f, 'b', 30, 32)) fmt.Println(strconv.FormatFloat(f, 'e', 30, 32)) fmt.Println(strconv.FormatFloat(f, 'E', 30, 32)) fmt.Println(strconv.FormatFloat(f, 'f', 30, 32)) fmt.Println(strconv.FormatFloat(f, 'g', 30, 32)) fmt.Println(strconv.FormatFloat(f, 'G', 30, 32)) } ~~~ 輸出結果： ~~~ 13123382p-17 1.00123e+02 1.00123E+02 100.12346 100.12 100.12 13123382p-17 1.001234588623046875000000000000e+02 1.001234588623046875000000000000E+02 100.123458862304687500000000000000 100.1234588623046875 100.1234588623046875 ~~~ AppendFloat 將浮點數 f 轉換為字符串值，并將轉換結果追加到 []byte 的尾部返回追加后的 []byte ~~~ package main import ( "fmt" "strconv" ) func main() { f := 100.12345678901234567890123456789 b := make([]byte, 0) b = strconv.AppendFloat(b, f, 'f', 5, 32) b = append(b, " "...) b = strconv.AppendFloat(b, f, 'e', 5, 32) fmt.Printf("%s\n", b) } ~~~ 輸出結果： ~~~ 100.12346 1.00123e+02 ~~~ Quote 將字符串 s 轉換為“雙引號”引起來的字符串其中的特殊字符將被轉換為“轉義字符” 不可顯示的字符”將被轉換為“轉義字符” ~~~ package main import ( "fmt" "strconv" ) func main() { fmt.Println(strconv.Quote(`C:\Windows`)) } ~~~ 輸出結果： ~~~ "C:\\Windows" ~~~ AppendQuote 將字符串 s 轉換為“雙引號”引起來的字符串，并將結果追加到 []byte 的尾部，返回追加后的 []byte 其中的特殊字符將被轉換為“轉義字符” ~~~ package main import ( "fmt" "strconv" ) func main() { s := `C:\Windows` b := make([]byte, 0) b = strconv.AppendQuote(b, s) fmt.Printf("%s\n", b) } ~~~ 輸出結果： ~~~ "C:\\Windows" ~~~ QuoteToASCII 將字符串 s 轉換為“雙引號”引起來的 ASCII 字符串 “非 ASCII 字符”和“特殊字符”將被轉換為“轉義字符” ~~~ package main import ( "fmt" "strconv" ) func main() { asc := strconv.QuoteToASCII("Hello 世界！") fmt.Println(asc) } ~~~ 輸出結果： ~~~ "Hello \u4e16\u754c\uff01" ~~~ AppendQuoteToASCII 將字符串 s 轉換為“雙引號”引起來的 ASCII 字符串，并將結果追加到 []byte 的尾部，返回追加后的 []byte 非 ASCII 字符”和“特殊字符”將被轉換為“轉義字符” ~~~ package main import ( "fmt" "strconv" ) func main() { s := "Hello 世界！" b := make([]byte, 0) b = strconv.AppendQuoteToASCII(b, s) fmt.Printf("%s\n", b) } ~~~ 輸出結果： ~~~ "Hello \u4e16\u754c\uff01" ~~~ QuoteRune 將 Unicode 字符轉換為“單引號”引起來的字符串特殊字符”將被轉換為“轉義字符” ~~~ package main import ( "fmt" "strconv" ) func main() { str := strconv.QuoteRune('哈') fmt.Println(str) } ~~~ 輸出結果： ~~~ '哈' ~~~ AppendQuoteRune 將 Unicode 字符轉換為“單引號”引起來的字符串，并將結果追加到 []byte 的尾部，返回追加后的 []byte 特殊字符”將被轉換為“轉義字符” ~~~ package main import ( "fmt" "strconv" ) func main() { b := make([]byte, 0) b = strconv.AppendQuoteRune(b, '哈') fmt.Printf("%s\n", b) } ~~~ 輸出結果： ~~~ '哈' ~~~ QuoteRuneToASCII 將 Unicode 字符轉換為“單引號”引起來的 ASCII 字符串 “非 ASCII 字符”和“特殊字符”將被轉換為“轉義字符” ~~~ package main import ( "fmt" "strconv" ) func main() { asc := strconv.QuoteRuneToASCII('哈') fmt.Println(asc) } ~~~ 輸出結果： ~~~ '\u54c8' ~~~ AppendQuoteRune 將 Unicode 字符轉換為“單引號”引起來的 ASCII 字符串，并將結果追加到 []byte 的尾部，返回追加后的 []byte “非 ASCII 字符”和“特殊字符”將被轉換為“轉義字符” ~~~ package main import ( "fmt" "strconv" ) func main() { b := make([]byte, 0) b = strconv.AppendQuoteRuneToASCII(b, '哈') fmt.Printf("%s\n", b) } ~~~ 輸出結果： ~~~ '\u54c8' ~~~ CanBackquote 判斷字符串 s 是否可以表示為一個單行的“反引號”字符串字符串中不能含有控制字符（除了 \t）和“反引號”字符，否則返回 false ~~~ package main import ( "fmt" "strconv" ) func main() { b := strconv.CanBackquote("C:\\Windows\n") fmt.Printf("\\n is %v\n", b) b = strconv.CanBackquote("C:\\Windows\r") fmt.Printf("\\r is %v\n", b) b = strconv.CanBackquote("C:\\Windows\f") fmt.Printf("\\f is %v\n", b) b = strconv.CanBackquote("C:\\Windows\t") fmt.Printf("\\t is %v\n", b) b = strconv.CanBackquote("C:\\Windows`") fmt.Printf("` is %v\n", b) } ~~~ 輸出結果： ~~~ \n is false \r is false \f is false \t is true ` is false ~~~ UnquoteChar 將 s 中的第一個字符“取消轉義”并解碼 s：轉義后的字符串 quote：字符串使用的“引號符”（用于對引號符“取消轉義”） value：解碼后的字符 multibyte：value 是否為多字節字符 tail：字符串 s 除去 value 后的剩余部分 error：返回 s 中是否存在語法錯誤參數 quote 為“引號符” 如果設置為單引號，則 s 中允許出現 \' 字符，不允許出現單獨的 ' 字符如果設置為雙引號，則 s 中允許出現 \" 字符，不允許出現單獨的 " 字符如果設置為 0，則不允許出現 \' 或 \" 字符，可以出現單獨的 ' 或 " 字符 ~~~ package main import ( "fmt" "strconv" ) func main() { s := `\"大\\家\\好！\"` c, mb, sr, _ := strconv.UnquoteChar(s, '"') fmt.Printf("%-3c %v\n", c, mb) for ; len(sr) > 0; c, mb, sr, _ = strconv.UnquoteChar(sr, '"') { fmt.Printf("%-3c %v\n", c, mb) } } ~~~ 輸出結果： ~~~ " false " false 大 true \ false 家 true \ false 好 true ！ true ~~~ Unquote 將“帶引號的字符串” s 轉換為常規的字符串（不帶引號和轉義字符） s 可以是“單引號”、“雙引號”或“反引號”引起來的字符串（包括引號本身）如果 s 是單引號引起來的字符串，則返回該該字符串代表的字符 ~~~ package main import ( "fmt" "strconv" ) func main() { sr, err := strconv.Unquote("\"大\t家\t好！\"") fmt.Println(sr, err) sr, err = strconv.Unquote(`'大家好！'`) fmt.Println(sr, err) sr, err = strconv.Unquote("'好'") fmt.Println(sr, err) sr, err = strconv.Unquote("大\\t家\\t好！") fmt.Println(sr, err) } ~~~ 輸出結果： ~~~ 大家好！ <nil> invalid syntax 好 <nil> invalid syntax ~~~ IsPrint 判斷 Unicode 字符 r 是否是一個可顯示的字符可否顯示并不是你想象的那樣，比如空格可以顯示，而\t則不能顯示 ~~~ package main import ( "fmt" "strconv" ) func main() { fmt.Println(strconv.IsPrint('a')) fmt.Println(strconv.IsPrint('好')) fmt.Println(strconv.IsPrint(' ')) fmt.Println(strconv.IsPrint('\t')) fmt.Println(strconv.IsPrint('\n')) fmt.Println(strconv.IsPrint(0)) } ~~~ 輸出結果： ~~~ true true true false false false ~~~