一、字符串和切片之间的转换
>> 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 = 100v3 := 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) // 将字符串转化为无符号整型，参数含义同 FormatIntv10 := "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转换后值可能不同，但是在内存存储二进制一模一样。
