Golang 中的 bytes 包详解：bytes.Buffer

golang 中的 bytes 包是其中一个 IO 操作标准库，实现了对字节切片（[]byte）的操作，提供了类似于 strings 包的功能。本文先讲解一下 bytes 包中的结构体 bytes.Buffer。

bytes.Buffer
bytes.Buffer 实现了 io.Writer、io.Reader、io.ByteScanner、io.RuneScanner、io.WriterTo、io.ByteWriter 和 io.ReaderFrom 等接口，可以很方便地实现对字节数据的读写和操作。主要特点是提供了一个缓冲区，可以在内存中动态分配缓冲区，以高效地写入和读取字节数据。在处理数据时，特别是数据拼接操作时，效率往往比直接使用字符串拼接要高很多。结构体定义和对应的方法如下：

type Buffer struct {
    buf      []byte // contents are the bytes buf[off : len(buf)]
    off      int    // read at &buf[off], write at &buf[len(buf)]
    lastRead readOp // last read operation, so that Unread* can work correctly.
}

其中，buf 保存了实际的字节缓存，off 表示下一个读写操作的偏移量，lastRead 表示最后一次读取操作的类型和大小。

bytes.Buffer 提供的主要方法包括：

ReadFrom，从 io.Reader 中读取数据，并写入到缓冲区中。
WriteTo，从缓冲区中读取数据，并写入到 io.Writer 中。
WriteByte、WriteRune、WriteString，分别用于将单个字节、Unicode 字符和字符串写入缓冲区中。
ReadByte、ReadRune、ReadString，分别用于从缓冲区中读取单个字节、Unicode 字符和字符串。
Bytes、String，返回缓冲区中的字节切片和字符串。
Reset，用于重置缓冲区，将其扩容为默认大小（64 字节）。
其他方法就不一一说明了，最好自己去看去使用去体会。

使用示例

    buf := bytes.Buffer{}
    buf.WriteByte(255)
    buf.WriteByte(2)
    var uid1 = "beijing1@90099@"
    buf.WriteString(uid1)
#添加分隔符字任意符串 读取时候的节点
    buf.WriteString("\n")
    var sid1 = "9559912xiao"
    buf.WriteString(sid1)
    buf.WriteString("\n")
    var cid1 int64 = 123456456
    buf.Write(utils.Int64ToBytes(cid1))
    buf.WriteString("\n")
    //buf2 := bytes.Buffer{}
    var mes []model.MessageModel
    mes = append(mes, model.MessageModel{Type: "XXXXXX", Act: "1"})
    mes = append(mes, model.MessageModel{Type: "XXXXXX", Act: "2"})
    d, _ := json.Marshal(mes)
    buf.Write(d)

    var data = []model.MessageModel{}
    tp, _ := buf.ReadByte()
    dttype, _ := buf.ReadByte()
    // 读取一个字符串
    uid, err := buf.ReadBytes('\n')
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println("uid:", "---", string(uid), "\n")
#读取这个分隔符前面的所有内容
    sid, err := buf.ReadBytes('\n')
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println("sid:", "---", string(sid), "\n")
    cid, err := buf.ReadBytes('\n')
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println("cid:", "---", utils.BytesToInt64(cid), "\n")

    fmt.Println("tp:", tp, ";dttype:", dttype)
    dt := buf.Bytes()
    //fmt.Println("--------\n")
    err = json.Unmarshal(dt, &data)
    if err != nil {
        return
    }
    fmt.Println(data)
    return

简单使用示例如下：

package main
 
import (
    "bytes"
    "encoding/binary"
    "fmt"
    "io"
    "os"
)
 
func main() {
    var buf bytes.Buffer
 
    // 写入一个字节
    err := buf.WriteByte('a')
    if err != nil {
        fmt.Println(err)
        return
    }
 
    // 写入一个字符串
    _, err = buf.WriteString("b")
    if err != nil {
        fmt.Println(err)
        return
    }
 
    // 写入一个无符号整数
    var u uint32 = 12345
    err = binary.Write(&buf, binary.LittleEndian, u)
    if err != nil {
        fmt.Println(err)
        return
    }
 
    // 读取一个字节
    b, err := buf.ReadByte()
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(string(b)) // a
 
    // 读取一个字符串
    s, err := buf.ReadString('\n')
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(s) // b
 
    // 读取无符号整数
    var u2 uint32
    err = binary.Read(&buf, binary.LittleEndian, &u2)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(u2) // 12345
 
    // 拷贝到标准输出中
    _, err = io.Copy(os.Stdout, &buf)
    if err != nil {
        fmt.Println(err)
        return
    }
 
    // 读取到 []byte 中，并以字符串输出
    data, err := io.ReadAll(&buf)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(string(data))
}

首先创建了一个 bytes.Buffer 对象 buf，分别使用 WriteByte、WriteString 和 binary.Write 方法向缓冲区中写入一个字节、一个字符串和一个无符号整数。然后分别使用 ReadByte、ReadString 和 binary.Read 方法从缓冲区中读取了一个字节、一个字符串和一个无符号整数。接下来使用 io.Copy 方法和 os.Stdout 将缓冲区中的数据拷贝到标准输出中，最后使用 io.ReadAll 方法将缓冲区中的所有数据读取到一个字节切片中，并转换为一个字符串。