go中之间的类型转换
一、字符串和切片之间的转换
>> 1 package main
2
3 import "fmt"
4
5
6 func main() {
7 | var testData string = "hello"
8 |
9 | //字符串转切片
10 | slice := []byte(testData)
11 | fmt.Printf("slice:%v\n", slice)
12
13 | //切片转字符串
14 | strData := string(slice)
15 | fmt.Printf("slice:%s\n", strData)
10 }
结果：
slice:[104 101 108 108 111]
slice:hello
二、切片和整型之间的转换
>> 1 package main
2
3 import (
4 | "encoding/binary"
5 | "fmt"
6 )
7
8
9 func main() {
10 | var intData uint32 = 1024
11 | var sliceData []byte
12
13 | //整型转切片
14 | sliceData = make([]byte, 4)
15 | binary.LittleEndian.PutUint32(sliceData, intData)
16 | fmt.Printf("intData:%v\n", sliceData)
17
18 | //切片转整型
19 | aa := binary.LittleEndian.Uint32(sliceData)
20 | fmt.Printf("aa:%v\n", aa)
21 }
结果：
intData:[0 4 0 0]
aa:1024
三、结构体和切片之间的转换
>> 1 package main
2
3 import (
4 | "bytes"
5 | "encoding/binary"
6 | "fmt"
7 )
8
9
10 func main() {
11 | type structData struct {
12 | | intData uint32
13 | | strData []byte
14 | }
15
16 | var ss = structData{intData: 12}
17 | var buffer = bytes.Buffer{}
18 | err := binary.Write(&buffer, binary.BigEndian, ss.intData)
19 | if err != nil {
20 | | fmt.Printf("err")
21 | }
22
23 | ss.strData = make([]byte, 10)
24 | copy(ss.strData, []byte("heloo"))
25 | err = binary.Write(&buffer, binary.BigEndian, ss.strData)
26 | if err != nil {
27 | | fmt.Printf("err")
28 | }
29
30 | fmt.Printf("struct:%v\n", buffer)
31 }
结果：
struct:{[0 0 0 12 104 101 108 111 111 0 0 0 0 0] 0 0}
由于err = binary.Write(&buffer, binary.BigEndian, ss.strData)这个函数的最后一个参数是需要有固定大小的参数，才能写入，因此 如果没有初始化的话，会之间报错。
如果结构体中的各个 参数 都是有固定长度的也可以这样写：
>> 1 package main
2
3 import (
4 | "bytes"
5 | "encoding/binary"
6 | "fmt"
7 )
8
9
10 func main() {
11 | type structData struct {
12 | | intData uint32
13 | | strData uint32
14 | }
15
16 | var ss = structData{intData: 12, strData: 12}
17 | var buffer = bytes.Buffer{}
18 | err := binary.Write(&buffer, binary.BigEndian, ss.intData)
19 | if err != nil {
20 | | fmt.Printf("err")
21 | }
22
23 | err = binary.Write(&buffer, binary.BigEndian, ss.strData)
24 | if err != nil {
25 | | fmt.Printf("err")
26 | }
27
28 | fmt.Printf("struct:%v\n", buffer)
29 }
~
结果:
struct:{[0 0 0 12 0 0 0 12] 0 0}
四、字符串和整型之间的转换
>> 1 package main
2
3 import (
4 | "fmt"
5 | "strconv"
6 )
7
8
9 func main() {
10 | //字符串转整型
11 | ss, err := strconv.Atoi("12")
12 | if err != nil {
13 | | fmt.Printf("err")
14 | }
15 | fmt.Printf("ss:%d\n", ss)
16
17 | aa := strconv.Itoa(ss)
18 | fmt.Printf("aa:%s\n", aa)
19
20 }
结果：
ss:12
aa:12
补充：
v1 := "100"
v2, _ := strconv.Atoi(v1) // 将字符串转化为整型，v2 = 100
v3 := 100
v4 := strconv.Itoa(v3) // 将整型转化为字符串, v4 = "100"
v5 := "true"
v6, _ := strconv.ParseBool(v5) // 将字符串转化为布尔型
v5 = strconv.FormatBool(v6) // 将布尔值转化为字符串
v7 := "100"
v8, _ := strconv.ParseInt(v7, 10, 64) // 将字符串转化为整型，第二个参数表示进制，第三个参数表示最大位数
v7 = strconv.FormatInt(v8, 10) // 将整型转化为字符串，第二个参数表示进制
v9, _ := strconv.ParseUint(v7, 10, 64) // 将字符串转化为无符号整型，参数含义同 ParseInt
v7 = strconv.FormatUint(v9, 10) // 将字符串转化为无符号整型，参数含义同 FormatInt
v10 := "99.99"
v11, _ := strconv.ParseFloat(v10, 64) // 将字符串转化为浮点型，第二个参数表示精度
v10 = strconv.FormatFloat(v11, 'E', -1, 64)
q := strconv.Quote("Hello, 世界") // 为字符串加引号
q = strconv.QuoteToASCII("Hello, 世界") // 将字符串转化为 ASCII 编码
五、杂项
var f float64
bits = *(*uint64)(unsafe.Pointer(&f))
type ptr unsafe.Pointer
bits = *(*uint64)(ptr(&f))
var p ptr = nil
float64就强制转换成uint64类型，float的地址就是一个值但是类型是float64，然后创建了一个uint64类型变量，地址值也是float64的地址值，两个变量值相同类型不同，强制转换了类型。
unsafe强制转换是指针的底层操作了，用c的朋友就很熟悉这样的指针类型转换，利用内存对齐才能保证转换可靠，例如int和uint存在符号位差别，利用unsafe转换后值可能不同，但是在内存存储二进制一模一样。