Go语言中结构体struct与字节数组[]byte的相互转换

这两种数据结构在数据解析中很常见，需要做转换。尤其是对于结构体中是字符串这样非固定长度的类型的转换，需要注意最后一种解决方案。
如果有看过你了解unsafe.Pointer这个不安全指针吗？那就更好办了，在go语言中，我们知道指针类型直接转换是不行的，需要借助这个不安全指针来做桥梁。

struct转换成[]byte

想要转换成[]byte，字节数组我们看源码知道，是无符号8位整型：type byte = uint8，它的真实构造其实跟slice一样：

type slice struct {
    array unsafe.Pointer // 指向底层数组
    len int // 长度，必选
    cap int // 容量，可选
}

那么我们就模拟构造这样一个类似的数据结构SimulatedSlice：

package main
 
import (
	"fmt"
	"unsafe"
)
 
type Info struct {
	data  int64
	data2 float64
	data3 string
}
 
type SimulatedSlice struct {
	array uintptr
	len   int
	cap   int
}
 
func main() {
	var info = &Info{80, 1.23, "abc"}
	Len := unsafe.Sizeof(*info)
	simSlice := &SimulatedSlice{
		array: uintptr(unsafe.Pointer(info)),
		cap:   int(Len),
		len:   int(Len),
	}
	data := *(*[]byte)(unsafe.Pointer(simSlice))
	fmt.Printf("%v\n", data)
}
//[80 0 0 0 0 0 0 0 174 71 225 122 20 174 243 63 208 143 214 0 0 0 0 0 3 0 0 0 0 0 0 0]

可以看到结构体的三个成员变量都分别转成了[]byte。就是通过unsafe.Pointer这样的不安全指针来做桥梁，然后前面就可以直接强制类型转换了。

[]byte转换成struct

上面是结构体转成了字节数组对吧，然后我们将生成的字节数组转换成结构体，同时也可以验证前面的转换是否正确：

var mystruct *Info = *(**Info)(unsafe.Pointer(&data))
fmt.Printf("%#v,%#v,%#v,%#s\n", mystruct, mystruct.data, mystruct.data2, mystruct.data3)
//&main.Info{data:80, data2:1.23, data3:"abc"},80,1.23,abc

可以看出生成的结果没有问题，将data生成的字节数组还原成了结构体。除了使用不安全指针做桥梁之外，另外一种使用binary来转换。

binary将struct转[]byte

需要引入"encoding/binary"库，我们来看下：

package main
 
import (
	"bytes"
	"encoding/binary"
	"fmt"
)
 
type Info struct {
	data  int64
	data2 float64
	//data3 string
}
 
func main() {
	info := &Info{80, 1.23}
	//info := &Info{80, 1.23, "abc"}
	buf := &bytes.Buffer{}
	err := binary.Write(buf, binary.LittleEndian, info)
	if err != nil {
		panic(err)
	}
	fmt.Println(buf.Bytes())
}
//[80 0 0 0 0 0 0 0 174 71 225 122 20 174 243 63]

这种方式也可以转成字节数组，就是将结构体初始化之后，通过binary的Write方法，写入到Buffer中即可。
当我们将里面的成员变量data3去掉注释，运行之后发现报错：

"binary.Write: invalid type *main.Info"

这里的原因是string类型，属于非固定长度的类型，所以不行，那成员变量有字符串类型想要转成字节数组如何处理呢？使用另一种方案，就是gob

gob将struct转[]byte

需要引用"encoding/gob"库，上面不能处理string类型，我们换这种方式来看下，处理string的代码：
注意成员变量首字母大写，不然报错：gob: type main.Info has no exported fields

package main
 
import (
	"bytes"
	"encoding/gob"
	"fmt"
)
 
type Info struct {
	Data  int64
	Data2 float64
	Data3 string
}
 
func main() {
	info := &Info{Data: 80, Data2: 1.23, Data3: "abc"}
	buf := new(bytes.Buffer)
	//gob编码
	enc := gob.NewEncoder(buf)
	if err := enc.Encode(info); err != nil {
		fmt.Println(err)
	}
	fmt.Printf("%v\n", buf.Bytes())
	/*
	[47 255 129 3 1 1 4 73 110 102 111 1 255 130 0 1 3 1 4 68 97 116 97 1 4 0 1 5 68 97 116 97 50 1 8 0 1 5 68 97 116 97 51 1 12 0 0 0 21 255 130 1 255 160 1 248 174 71 225 122 20 174 243 63 1 3 97 98 99 0]
	*/
	//gob解码
	dec := gob.NewDecoder(buf)
	var info2 *Info
	if err := dec.Decode(&info2); err != nil {
		fmt.Println(err)
	}
	fmt.Printf("%+v", info2) //&{Data:80 Data2:1.23 Data3:abc}
}

这样就通过对字节数组进行编码，然后解码到结构体即可，通过这种编码解码的方式，就处理了结构体里面的成员变量为非固定大小的类型。

相关知识参阅：Go语言进阶，结构体与json字符串格式的互相转换