Golang标准库binary

最新推荐文章于 2024-06-15 11:13:53 发布
最新推荐文章于 2024-06-15 11:13:53 发布
阅读量2.9k 收藏 8
点赞数 1
分类专栏： golang 文章标签： golang 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/peerless__/article/details/121443159
版权

binary包实现了数字和字节序列之间的简单转换。

1、ByteOrder

ByteOrder指定了如何将一个字节序列转换为16、32或64位的无符号整数：

type ByteOrder interface {
	Uint16([]byte) uint16
	Uint32([]byte) uint32
	Uint64([]byte) uint64
	PutUint16([]byte, uint16)
	PutUint32([]byte, uint32)
	PutUint64([]byte, uint64)
	String() string
}

ByteOrder是一个接口，在binary中有两个实现了该接口的结构体，分别是littleEndian和bigEndian，也就是小端和大端。大端小端指的是数据如何存储在内存中，比如：将低位字节存储在低地址空间中、高位字节存储在高地址空间中就是小端字节序；相反，将低位字节存储在高地址空间中、高位字节存储在低地址空间中就是大端字节序。

例如：十六进制数0X12345678以小端和大端字节序分别在内存中的存储方式如下：

在这里插入图片描述

littleEndian：

littleEndian在其它包中是无法创建的，但是在binary中已经创建了一个名为LittleEndian的该结构体，我们可以直接使用。

var LittleEndian littleEndian

type littleEndian struct{}

func (littleEndian) Uint16(b []byte) uint16 {
	_ = b[1] // 编译器的边界检测提示
	return uint16(b[0]) | uint16(b[1])<<8
}

func (littleEndian) PutUint16(b []byte, v uint16) {
	_ = b[1] // early bounds check to guarantee safety of writes below
	b[0] = byte(v)
	b[1] = byte(v >> 8)
}

func (littleEndian) Uint32(b []byte) uint32 {
	_ = b[3] // bounds check hint to compiler; see golang.org/issue/14808
	return uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
}

func (littleEndian) PutUint32(b []byte, v uint32) {
	_ = b[3] // early bounds check to guarantee safety of writes below
	b[0] = byte(v)
	b[1] = byte(v >> 8)
	b[2] = byte(v >> 16)
	b[3] = byte(v >> 24)
}

func (littleEndian) Uint64(b []byte) uint64 {
	_ = b[7] // bounds check hint to compiler; see golang.org/issue/14808
	return uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 |
		uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
}

func (littleEndian) PutUint64(b []byte, v uint64) {
	_ = b[7] // early bounds check to guarantee safety of writes below
	b[0] = byte(v)
	b[1] = byte(v >> 8)
	b[2] = byte(v >> 16)
	b[3] = byte(v >> 24)
	b[4] = byte(v >> 32)
	b[5] = byte(v >> 40)
	b[6] = byte(v >> 48)
	b[7] = byte(v >> 56)
}

func (littleEndian) String() string { return "LittleEndian" }

func (littleEndian) GoString() string { return "binary.LittleEndian" }

在上面定义的方法也比较简单，就是字节序列与无符号数之间的转换。例如Uint16这个方法，在这里是小端字节序，因此低字节存储在低地址空间中，随着切片的索引的增大，地址空间也是增大的，所以b[1]所在空间是高地址，因此将b[1]左移八位后与b[0]位与就可以得到uint16类型的数据了。

bigEndian：

大端与小端相反：

var BigEndian bigEndian

type bigEndian struct{}

func (bigEndian) Uint16(b []byte) uint16 {
	_ = b[1] // bounds check hint to compiler; see golang.org/issue/14808
	return uint16(b[1]) | uint16(b[0])<<8
}

func (bigEndian) PutUint16(b []byte, v uint16) {
	_ = b[1] // early bounds check to guarantee safety of writes below
	b[0] = byte(v >> 8)
	b[1] = byte(v)
}

func (bigEndian) Uint32(b []byte) uint32 {
	_ = b[3] // bounds check hint to compiler; see golang.org/issue/14808
	return uint32(b[3]) | uint32(b[2])<<8 | uint32(b[1])<<16 | uint32(b[0])<<24
}

func (bigEndian) PutUint32(b []byte, v uint32) {
	_ = b[3] // early bounds check to guarantee safety of writes below
	b[0] = byte(v >> 24)
	b[1] = byte(v >> 16)
	b[2] = byte(v >> 8)
	b[3] = byte(v)
}

func (bigEndian) Uint64(b []byte) uint64 {
	_ = b[7] // bounds check hint to compiler; see golang.org/issue/14808
	return uint64(b[7]) | uint64(b[6])<<8 | uint64(b[5])<<16 | uint64(b[4])<<24 |
		uint64(b[3])<<32 | uint64(b[2])<<40 | uint64(b[1])<<48 | uint64(b[0])<<56
}

func (bigEndian) PutUint64(b []byte, v uint64) {
	_ = b[7] // early bounds check to guarantee safety of writes below
	b[0] = byte(v >> 56)
	b[1] = byte(v >> 48)
	b[2] = byte(v >> 40)
	b[3] = byte(v >> 32)
	b[4] = byte(v >> 24)
	b[5] = byte(v >> 16)
	b[6] = byte(v >> 8)
	b[7] = byte(v)
}

func (bigEndian) String() string { return "BigEndian" }

func (bigEndian) GoString() string { return "binary.BigEndian" }

 

2、binary.Read

Read方法从一个reader中读取数据到data中，data必须是一个指针或一个固定大小的值或切片：

该方法也可以将reader中读取的数据赋值给结构体的各个字段中。

func Read(r io.Reader, order ByteOrder, data interface{}) error {
	// Fast path for basic types and slices.
	if n := intDataSize(data); n != 0 {
		bs := make([]byte, n)
		if _, err := io.ReadFull(r, bs); err != nil {
			return err
		}
		switch data := data.(type) {
		case *bool:
			*data = bs[0] != 0
		case *int8:
			*data = int8(bs[0])
		case *uint8:
			*data = bs[0]
		case *int16:
			*data = int16(order.Uint16(bs))
		case *uint16:
			*data = order.Uint16(bs)
		case *int32:
			*data = int32(order.Uint32(bs))
		case *uint32:
			*data = order.Uint32(bs)
		case *int64:
			*data = int64(order.Uint64(bs))
		case *uint64:
			*data = order.Uint64(bs)
		case *float32:
			*data = math.Float32frombits(order.Uint32(bs))
		case *float64:
			*data = math.Float64frombits(order.Uint64(bs))
		case []bool:
			for i, x := range bs { // Easier to loop over the input for 8-bit values.
				data[i] = x != 0
			}
		case []int8:
			for i, x := range bs {
				data[i] = int8(x)
			}
		case []uint8:
			copy(data, bs)
		case []int16:
			for i := range data {
				data[i] = int16(order.Uint16(bs[2*i:]))
			}
		case []uint16:
			for i := range data {
				data[i] = order.Uint16(bs[2*i:])
			}
		case []int32:
			for i := range data {
				data[i] = int32(order.Uint32(bs[4*i:]))
			}
		case []uint32:
			for i := range data {
				data[i] = order.Uint32(bs[4*i:])
			}
		case []int64:
			for i := range data {
				data[i] = int64(order.Uint64(bs[8*i:]))
			}
		case []uint64:
			for i := range data {
				data[i] = order.Uint64(bs[8*i:])
			}
		case []float32:
			for i := range data {
				data[i] = math.Float32frombits(order.Uint32(bs[4*i:]))
			}
		case []float64:
			for i := range data {
				data[i] = math.Float64frombits(order.Uint64(bs[8*i:]))
			}
		default:
			n = 0 // fast path doesn't apply
		}
		if n != 0 {
			return nil
		}
	}

	// Fallback to reflect-based decoding.
	v := reflect.ValueOf(data)
	size := -1
	switch v.Kind() {
	case reflect.Ptr:
		v = v.Elem()
		size = dataSize(v)
	case reflect.Slice:
		size = dataSize(v)
	}
	if size < 0 {
		return errors.New("binary.Read: invalid type " + reflect.TypeOf(data).String())
	}
	d := &decoder{order: order, buf: make([]byte, size)}
	if _, err := io.ReadFull(r, d.buf); err != nil {
		return err
	}
	d.value(v)
	return nil
}

 

3、binary.Write

Write方法将数据的二进制写入一个Writer中，data必须为一个固定值的值或者切片或指向该类数据的一个指针：

func Write(w io.Writer, order ByteOrder, data interface{}) error {
	// Fast path for basic types and slices.
	if n := intDataSize(data); n != 0 {
		bs := make([]byte, n)
		switch v := data.(type) {
		case *bool:
			if *v {
				bs[0] = 1
			} else {
				bs[0] = 0
			}
		case bool:
			if v {
				bs[0] = 1
			} else {
				bs[0] = 0
			}
		case []bool:
			for i, x := range v {
				if x {
					bs[i] = 1
				} else {
					bs[i] = 0
				}
			}
		case *int8:
			bs[0] = byte(*v)
		case int8:
			bs[0] = byte(v)
		case []int8:
			for i, x := range v {
				bs[i] = byte(x)
			}
		case *uint8:
			bs[0] = *v
		case uint8:
			bs[0] = v
		case []uint8:
			bs = v
		case *int16:
			order.PutUint16(bs, uint16(*v))
		case int16:
			order.PutUint16(bs, uint16(v))
		case []int16:
			for i, x := range v {
				order.PutUint16(bs[2*i:], uint16(x))
			}
		case *uint16:
			order.PutUint16(bs, *v)
		case uint16:
			order.PutUint16(bs, v)
		case []uint16:
			for i, x := range v {
				order.PutUint16(bs[2*i:], x)
			}
		case *int32:
			order.PutUint32(bs, uint32(*v))
		case int32:
			order.PutUint32(bs, uint32(v))
		case []int32:
			for i, x := range v {
				order.PutUint32(bs[4*i:], uint32(x))
			}
		case *uint32:
			order.PutUint32(bs, *v)
		case uint32:
			order.PutUint32(bs, v)
		case []uint32:
			for i, x := range v {
				order.PutUint32(bs[4*i:], x)
			}
		case *int64:
			order.PutUint64(bs, uint64(*v))
		case int64:
			order.PutUint64(bs, uint64(v))
		case []int64:
			for i, x := range v {
				order.PutUint64(bs[8*i:], uint64(x))
			}
		case *uint64:
			order.PutUint64(bs, *v)
		case uint64:
			order.PutUint64(bs, v)
		case []uint64:
			for i, x := range v {
				order.PutUint64(bs[8*i:], x)
			}
		case *float32:
			order.PutUint32(bs, math.Float32bits(*v))
		case float32:
			order.PutUint32(bs, math.Float32bits(v))
		case []float32:
			for i, x := range v {
				order.PutUint32(bs[4*i:], math.Float32bits(x))
			}
		case *float64:
			order.PutUint64(bs, math.Float64bits(*v))
		case float64:
			order.PutUint64(bs, math.Float64bits(v))
		case []float64:
			for i, x := range v {
				order.PutUint64(bs[8*i:], math.Float64bits(x))
			}
		}
		_, err := w.Write(bs)
		return err
	}

	// Fallback to reflect-based encoding.
	v := reflect.Indirect(reflect.ValueOf(data))
	size := dataSize(v)
	if size < 0 {
		return errors.New("binary.Write: invalid type " + reflect.TypeOf(data).String())
	}
	buf := make([]byte, size)
	e := &encoder{order: order, buf: buf}
	e.value(v)
	_, err := w.Write(buf)
	return err
}

 

4、binary.Read和binary.Write的应用

当我们使用tcp传输数据时，常常会遇到粘包的现象，因此为了解决粘包我们需要告诉对方我们发送的数据包的大小。一般是使用TLV类型的数据协议，分别是Type、Len、Value，Type和Len为数据头，可以将这个两个字段都固定为四个字节。读取数据时，先将Type和Len读取出来，然后再根据Len来读取剩余的数据：

例如我们使用客户端向一个服务端发送数据：

client：

package main

import (
	"bytes"
	"encoding/binary"
	"fmt"
	"net"
)

// 对数据进行编码
func Encode(id uint32, msg []byte) []byte {
	var dataLen uint32 = uint32(len(msg))

	// *Buffer实现了Writer
	buffer := bytes.NewBuffer([]byte{})
    // 将id写入字节切片
	if err := binary.Write(buffer, binary.LittleEndian, &id); err != nil {
		fmt.Println("Write to buffer error:", err)
	}
	// 将数据长度写入字节切片
	if err := binary.Write(buffer, binary.LittleEndian, &dataLen); err != nil {
		fmt.Println("Write to buffer error:", err)
	}
	
    // 最后将数据添加到后面
	msg = append(buffer.Bytes(), msg...)

	return msg
}

func main() {
	dial, err := net.Dial("tcp4", "127.0.0.1:6666")
	if err != nil {
		fmt.Println("Dial tcp error:", err)
	}
	
    // 向服务端发送hello,world!
	msg := []byte("hello,world!")
	var id uint32 = 1

	data := Encode(id, msg)
	dial.Write(data)

	dial.Close()
}

// 运行结果：
Receive Data, Type:1, Len:12, Message:hello,world!
Connection has been closed by client

server：

package main

import (
	"bytes"
	"encoding/binary"
	"fmt"
	"io"
	"net"
)

// 解码，从字节切片中获取id和len
func Decode(encoded []byte) (id uint32, l uint32) {
	buffer := bytes.NewBuffer(encoded)
	if err := binary.Read(buffer, binary.LittleEndian, &id); err != nil {
		fmt.Println("Read from buffer error:", err)
	}

	if err := binary.Read(buffer, binary.LittleEndian, &l); err != nil {
		fmt.Println("Read from buffer error:", err)
	}

	return id, l
}

const MAX_PACKAGE = 4096

func DealConn(conn net.Conn) {
	defer conn.Close()

	head := make([]byte, 8)
	for {
        // 先读取8个字节的头部，也就是id和dataLen
		_, err := io.ReadFull(conn, head)
		if err != nil {
			if err == io.EOF {
				fmt.Println("Connection has been closed by client")
			} else {
				fmt.Println("Read error:", err)
			}
			return
		}

		id, l := Decode(head)
		if l > MAX_PACKAGE {
			fmt.Println("Received data grater than MAX_PACKAGE")
			return
		}
		
        // 然后读取剩余数据
		data := make([]byte, l)
		_, err = io.ReadFull(conn, data)
		if err != nil {
			if err == io.EOF {
				fmt.Println("Connection has been closed by client")
			} else {
				fmt.Println("Read error:", err)
			}
			return
		}

        // 打印收到的数据
		fmt.Printf("Receive Data, Type:%d, Len:%d, Message:%s\n",
			id, l, string(data))
	}

}

func main() {

	listener, err := net.Listen("tcp", "127.0.0.1:6666")
	if err != nil {
		fmt.Println("Listen tcp error:", err)
		return
	}


	for {
		conn, err := listener.Accept()
		if err != nil {
			fmt.Println("Accept error:", err)
            break
		}

		// 启动一个协程处理客户端
		go DealConn(conn)

	}

}

运行结果：
Receive Data, Type:1, Len:12, Message:hello,world!
Connection has been closed by client
CoreDump丶
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
binary包、bytes包：指定字节序列的读写
磨镜台的博客
05-25 1003
将data数据以指定字节序列写入w中 Write(w io.Writer, order ByteOrder, data interface{}) error 例如： var num uint32 //创建一个存放二进制的字节缓冲 buff := bytes.NewBuffer([]byte{}) //将datalen 写进buffer中 if err := binary.Write(buff, ...
关于binary.read
m0_68850524的博客
05-17 160
binary.read底层是用io.readfull实现的，多次调用该函数会依次读下去，而不是每次都从头开始，参考链接:关于io.readfull理解(但是这个例子中string.NewReader返回的reader是指针，不知道是不是因为这个原因，还有待继续扒):https://blog.csdn.net/huang_2016/article/details/124639763
golang常用库之- encoding/binary包 | 字节转换成整形、整形转换成字节、“大字端” 和 “小字端”
西京刀客
02-22 1640
encoding/binary包相对于效率更注重简单。 如果需要高效的序列化，特别是数据结构较复杂的，可以选择更高级的解决方案**， 例如encoding/gob包(Go语言自带的数据编码解码工具包)，或者采用ProtocolBuffer(跨语言)。
golang 序列化和反序列化（binary）
最新发布
qingyu3044的博客
06-15 293
encoding/binary包实现了简单的数字（固定长度的数字类型或者只包含定长值的结构体或数组）与字节系列的转换以及变长值的编解码。
golang -- 网络字节编解码(2)
hyl999的专栏
08-20 1054
以下是利用标准库binary来进行编解码   解码  ①使用bytes.NewReader/bytes.Buffer来存储要解码的ascii串 ②使用binary.Read来解码 package main import (     "bytes"     "encoding/binary"     "fmt" ) func main() {     var pi float6...
Golang中encoding/binary包的应用
yujikang123的博客
10-18 1523
Golang中encoding/binary包的应用介绍理解字节序（Byte sequences）、大字端（Big Endian）、小字端（Little Endian）变量方法 介绍 golang的binary包简单实现了数字（number）到字节序（byte sequences）的转换，以及64位整型（varint）的编码与解码。 首先简单看一下binary的结构与方法 理解字节序（Byte sequences）、大字端（Big Endian）、小字端（Little Endian） 字节序，即字节在电脑
leetcode-Golang:试着用Golang刷leetcode题库
05-12
5. **标准库**：Golang拥有强大的标准库，特别是在网络编程、I/O操作和文本处理方面。 回到这个项目，开发者创建了一个名为"leetcode-Golang-master"的文件夹，很可能包含了不同LeetCode问题的解决方案。每个问题的...
algo_golang
03-25
此外，Go 的标准库非常强大，包含网络编程、文件操作、加密算法等大量实用功能。 在这个 "algo_golang-master" 文件中，我们可以期待看到各种算法的 Go 实现，这些实现可能以单独的文件形式存在，每个文件对应一个...
ntp:golang ntp客户端
05-02
在标签“Go”中，我们可以理解为这个话题与Golang编程语言密切相关，讨论的是如何利用Golang的标准库来构建NTP客户端程序。 至于压缩包子文件的文件名称列表“ntp-master”，这可能是包含了一个完整的NTP客户端实现...
luago：golang实现卢阿
02-09
实现Lua虚拟机，编译器和标准库 Lua虚拟机和API 二进制Chunk 整体结构 binary_Chunk的整体结构如下 type binaryChunk struct { header // 头部信息，加载时用于校验版本号，大小端格式 sizeUpvalues byte ...
DataStructureByGo:使用golang实现常用的数据结构
03-18
Golang标准库中的container/heap包提供了对堆的支持。 5. **树**（Tree）：包括二叉树（Binary Tree）、平衡树（如AVL Tree、红黑树）等。二叉树有搜索、插入和删除等基本操作，而平衡树则保证了查找效率。在Golang...
go binary包
心如止水
04-09 896
最近在看一个第三方包的库源码，bigcache，发现其中用到了binary 里面的函数，所以准备研究一下。可以看到binary 包位于encoding/binary，也就是表示这个包的作用是编辑码作用的，看到文档给出的解释是用于数字和字节序的转换以及变长值的编解码。
Go编程实战：高效利用encoding/binary进行数据编解码
walkskyer的博客
03-07 1164
在某些情况下，标准的序列化方法可能不足以满足我们的需求。这时，我们可以通过实现自定义的二进制转换逻辑来处理特殊的数据类型或格式。= nil {return errreturn nil在这个例子中，CustomDate。
binary.write 和 binary.read
赵凯月的博客
03-17 655
此包实现了对数据与byte之间的转换，以及varint的编解码。2、binary为我们开发者提供了哪些内容？二、binary为我们开发者提供了哪些内容？转化成二进制格式与原本数据转字符串相比会更节省空间。golang中encoding/binary包。1、golang包中的binary包是什么？一、golang包中的binary包是什么？uvarint和varint的编解码。3、编解码有哪几种方法？数据的byte序列化转换。
Go语言的序列化与反序列化（binary） BigEndian LittleEndian
雪花凌落的盛夏
12-06 1064
binary包实现了简单的数字与字节序列的转换以及变长值的编解码。 数字翻译为定长值来读写，一个定长值，要么是固定长度的数字类型（int8, uint8, int16, float32, complex64, ...）或者只包含定长值的结构体或者数组。 变长值是使用一到多个字节编码整数的方法，绝对值较小的数字会占用较少的字节数。详情请参见：http://code.google.com/apis/protocolbuffers/docs/encoding.html。 本包相对于效率更注重简单。如果需要高
[go] binary.Write 小坑一个兼论go的错误处理哲学
聚焦游戏和图形引擎开发技术
01-23 3980
有如下go代码： const ( foo = 123 ) buffer := new(bytes.Buffer) binary.Write(buffer, binary.BigEndian, foo) fmt.Println(buffer.Len()) 输出结果是0，foo没有写入到buffer中。原因在于，binary包的Write内部调用了intDataSize函数获取foo的长度：
3.记一个go语言字节数组和结构体转换:binary-obiect(obj的结构为byte)
小豆角的博客
05-25 2416
//代码段一：message的占用空间大小固定 package main import ( "bytes" "encoding/binary" "fmt" ) type message struct{ id int32 len int32 data [4]byte //这个也可以是切片，但是如果是切片，需要解两次才能解成msg对象 } type pack struct{ } ...
golang中的字节序 binary BigEndian 大端 , LittleEndian 小端 理解与write写入注意事项
05-19 467
在golang的binary包中有2个字节系的变量定义BigEndian和LittleEndian 这个东西是go里面很有特点的玩意，我们在java, php等语言中是基本看不到，因为大部分的语言默认使用的是BigEndian 大端模式， 而go语言里面是你自己可选的。这个字节系大小端是与编译器运行平台的CPU架构有关， x86架构的CPU使用的是小端LittleEndian， 而x64架构的CPU基本上使用的是大端。示例代码 大小端单元测试用例。小端LittleEndian。Debug运行示意图。
二进制读写中的大字端(Big Endian)和小字端(Little Endian)
a_Treasure的博客
08-09 7588
Big Endian and Little Endian
golang标准库文档 chm
07-28
Go语言标准库文档提供了Go语言标准库的API文档，使用CHM格式方便开发者离线查阅。CHM文件是编译过的HTML帮助文件，结构和用法与HTML帮助文档类似。 golang标准库文档CHM可以通过官方网站下载并安装到本地。安装完成后，我们可以在本地的帮助文档中查看Go标准库的所有API文档，而无需每次都通过互联网访问。 CHM文档提供了标准库中所有函数、数据类型和方法的详细描述，包括输入输出、参数、返回值和使用示例等。通过查询、浏览和阅读，我们可以更好地理解Go标准库的各个方面，提高开发效率和代码质量。 与在线文档相比，CHM文档的一个优势是可以离线查阅。这意味着即使没有网络连接，我们仍然可以访问并查找所需的API文档。这在一些没有网络连接的环境下非常有用，比如开发者在火车上或飞机上也可以查看文档。 总之，golang标准库文档CHM提供了方便快捷的离线API文档查阅方式。通过这个CHM文件，开发者可以更好地了解Go语言标准库，并在开发过程中快速查找所需的文档。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值