learnGolang - 缓冲区bytes.Buffer

在研究bytes.Buffer时，发现一篇文章写得不错，将bytes.Buffer的常见功能已经整理得非常不错了，所以根据文章跟着梳理了一遍。

在测试过程中发现原文章中的一些小问题（可能是因为golang版本更新后导致的），正好自己也要总结，因此将文章转载了过来，原文在放在了本文的最后。

本文使用的Golang版本：go1.22.1, Linux系统。

# 1、`bytes.Buffer`简介

在 Go 语言中，bytes.Buffer 是一个预定义的类型，用于存储和操作字节序列。bytes.Buffer 类型提供了很多有用的方法，例如：读写字节、字符串、整数和浮点数等。

例如：

1
2
3
4
5
6
7
8


// 创建一个空的缓冲区
var buf bytes.Buffer

// 向缓冲区写入字符串
buf.WriteString("Hello, World!")

// 从缓冲区读取字符串
fmt.Println(buf.String()) // 输出：Hello, World!

# 2、创建`bytes.Buffer`

有两种方法创建缓冲区。

# 2.1 使用 `NewBuffer()` 函数创建

可以使用 bytes 包中的 NewBuffer 函数来创建一个新的缓冲区对象。它的方法定义如下：

1

func NewBuffer(buf []byte) *Buffer

其中，buf 参数是可选的，它可以用来指定缓冲区的初始容量。如果不指定该参数，则会创建一个默认容量为 64 字节的缓冲区。

例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package main

import (
    "bytes"
    "fmt"
)

func main() {
    buf := bytes.NewBufferString("hello world")
    fmt.Println(buf.String()) // 输出：hello world
}

# 2.2 使用 `bytes.Buffer` 结构体创建

另一种创建缓冲区对象的方式是直接声明一个 bytes.Buffer 类型的变量。这种方式比较简单，但是需要注意，如果使用这种方式创建的缓冲区没有被初始化，则其初始容量为 0，需要在写入数据之前进行扩容。

例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


package main

import (
    "bytes"
    "fmt"
)

func main() {
    var buf bytes.Buffer
    buf.WriteString("hello")
    buf.WriteString(" ")
    buf.WriteString("world")
    fmt.Println(buf.String()) // 输出：hello world
}

# 3、写入数据

创建好缓冲区之后，我们可以向其中写入数据。Buffer类型提供了多种方法来写入数据，其中最常用的是Write方法。它的方法定义如下：

1

func (b *Buffer) Write(p []byte) (n int, err error)

其中，p 参数是要写入缓冲区的字节切片，返回值 n 表示实际写入的字节数，err 表示写入过程中可能出现的错误。

除了 Write 方法之外，Buffer 类型还提供了一系列其他方法来写入数据，例如 WriteString、WriteByte、WriteRune 等。这些方法分别用于向缓冲区写入字符串、单个字节、单个 Unicode 字符等。

一个使用 Write 方法向缓冲区写入数据的示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package main

import (
    "bytes"
    "fmt"
)

func main() {
    buf := bytes.NewBuffer(nil)
    n, err := buf.Write([]byte("hello world"))
    if err != nil {
        fmt.Println("write error:", err)
    }
    fmt.Printf("write %d bytes\n", n) // 输出：write 11 bytes
    fmt.Println(buf.String()) // 输出：hello world
}

# 4、读取数据

Buffer 类型提供了多种方法来读取数据，其中最常用的是 Read 方法。它的方法定义如下：

1

func (b *Buffer) Read(p []byte) (n int, err error)

其中，p 参数是用于存放读取数据的字节切片，返回值 n 表示实际读取的字节数，err 表示读取过程中可能出现的错误。

除了 Read 方法之外，Buffer 类型还提供了一系列其他方法来读取数据，例如 ReadString、ReadByte、ReadRune 等。这些方法分别用于从缓冲区读取字符串、单个字节、单个 Unicode 字符等。

例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


package main

import (
    "bytes"
    "fmt"
)

func main() {
    buf := bytes.NewBufferString("hello world")
    data := make([]byte, 5)
    n, err := buf.Read(data)
    if err != nil {
        fmt.Println("read error:", err)
    }
    fmt.Printf("read %d bytes\n", n) // 输出：read 5 bytes
    fmt.Println(string(data)) // 输出：hello
}

# 5、截取缓冲区

Buffer 类型提供了 Bytes 方法和 String 方法，用于将缓冲区的内容转换为字节切片和字符串。另外，还可以使用 Truncate 方法来截取缓冲区的内容。它的方法定义如下：

1

func (b *Buffer) Truncate(n int)

其中，n 参数表示要保留的字节数。

如果缓冲区的内容长度超过了 n，则会从尾部开始截取，只保留前面的 n 个字节。如果缓冲区的内容长度不足 n，则会产生一个panic。

例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


package main

import (
    "bytes"
    "fmt"
)

func main() {
    buf := bytes.NewBufferString("hello world")
    buf.Truncate(5)
    fmt.Println(buf.String()) // 输出：hello
}

# 6、扩容缓冲区

在写入数据的过程中，如果缓冲区的容量不够，就需要进行扩容。Buffer 类型提供了 Grow 方法来扩容缓冲区。它的方法定义如下：

1

func (b *Buffer) Grow(n int)

其中，n 参数表示要扩容的字节数。经过验证，其扩容方法如果下：

默认分配的缓存区容量为32；
在调用Grow()方法扩容时，会以32为step进行递增；
调用Grow(n)方法时，会计算buf.Len() + n的值，容量会根据该值向上递增为32的倍数；

例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


import (
    "bytes"
    "fmt"
)

func main() {
    buf := bytes.NewBufferString("hello")
    fmt.Printf("len=%d, cap=%d\n", buf.Len(), buf.Cap()) // 输出：len=5, cap=32
    buf.Grow(30)
    fmt.Printf("len=%d, cap=%d\n", buf.Len(), buf.Cap()) // 输出：len=5, cap=64
}

需要注意的是，Buffer 类型并不保证扩容后的缓冲区是连续的，因此在将缓冲区的内容传递给需要连续内存的接口时，需要先将缓冲区的内容拷贝到一个新的连续内存中。

# 7、重置缓冲区

在有些情况下，我们需要重复使用一个缓冲区。此时，可以使用 Reset 方法将缓冲区清空并重置为初始状态。它的方法定义如下：

1

func (b *Buffer) Reset()

例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package main

import (
        "bytes"
        "fmt"
)

func main() {
        buf := bytes.NewBufferString("hello")
        fmt.Println(buf.String()) // 输出：hello
        buf.Grow(60)
        fmt.Printf("len=%d, cap=%d\n", buf.Len(), buf.Cap()) // 输出：len=5, cap=80
        buf.Reset()
        fmt.Println(buf.String())                            // 输出：
        fmt.Printf("len=%d, cap=%d\n", buf.Len(), buf.Cap()) // 输出：len=0, cap=80
}

重置后，缓冲区长度变为0，容量不变。

# 8、序列化与反序列化

由于 bytes.Buffer 类型支持读写操作，它可以用于序列化和反序列化结构体、JSON、XML 等数据格式。这使得 bytes.Buffer 类型在网络通信和分布式系统中的应用变得更加便捷。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


package main

import (
        "bytes"
        "encoding/json"
        "fmt"
)

type Person struct {
        Name string
        Age  int
}

func main() {
        var buf bytes.Buffer

        // 将结构体编码为 JSON
        p := Person{"Alice", 25}
        enc := json.NewEncoder(&buf)
        enc.Encode(p)
        fmt.Println(buf.String()) // 输出：{"Name":"Alice","Age":25}

        // 从 JSON 解码为结构体
        var p2 Person
        dec := json.NewDecoder(&buf)
        dec.Decode(&p2)
        fmt.Printf("Name: %s, Age: %d\n", p2.Name, p2.Age) // 输出：Name: Alice, Age: 25
}

# 9、`bytes.Buffer`的应用场景

# 9.1 网络通信

在网络通信中，bytes.Buffer 可以用于存储和处理 TCP/UDP 数据包、HTTP 请求和响应等数据。例如，我们可以使用 bytes.Buffer 类型来构造 HTTP 请求和响应：

1
2
3
4
5


// 构造 HTTP 请求
req := bytes.NewBufferString("GET / HTTP/1.0\r\n\r\n")

// 构造 HTTP 响应
resp := bytes.NewBuffer([]byte("HTTP/1.0 200 OK\r\nContent-Type: text/html\r\n\r\nHello, World!"))

# 9.2 文件操作

在文件操作中，bytes.Buffer 可以用于缓存文件内容，以避免频繁的磁盘读写操作。例如，我们可以使用 bytes.Buffer 类型来读取和写入文件：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


package main

import (
    "bytes"
    "fmt"
    "io"
    "log"
    "os"
)

func main() {
    var buf bytes.Buffer

    // 从文件中读取数据
    file, err := os.Open("encoder.go")
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()

    _, err = io.Copy(&buf, file)
    if err != nil {
        log.Fatal(err)
    }
    // 将数据输出到终端
    fmt.Println(buf.String())

    // 将数据写入文件
    out, err := os.Create("output.txt")
    if err != nil {
        log.Fatal(err)
    }
    defer out.Close()

    _, err = io.Copy(out, &buf)
    if err != nil {
        log.Fatal(err)
    }
}

# 9.3 二进制数据处理

在处理二进制数据时，bytes.Buffer 可以用于存储和操作字节数组。例如，我们可以使用 bytes.Buffer 类型来读写字节数组、转换字节数组的大小端序等操作：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


package main

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

func main() {
    // 读取字节数组
    data := []byte{0x48, 0x65, 0x6c, 0x6c, 0x6f}
    var buf bytes.Buffer
    buf.Write(data)

    // 转换大小端序
    var num uint16
    binary.Read(&buf, binary.BigEndian, &num)
    fmt.Println(num) // 输出：0x4865

    // 写入字节数组
    data2 := []byte{0x57, 0x6f, 0x72, 0x6c, 0x64, 0x21}
    buf.Write(data2)
    fmt.Println(buf.Bytes()) // 输出：[72 101 108 108 111 87 111 114 108 100 33]
}

# 9.4 字符串拼接

在字符串拼接时，如果直接使用 + 运算符会产生大量的中间变量，影响程序的效率。使用 Buffer 类型可以避免这个问题。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


package main

import (
    "bytes"
    "fmt"
)

func concatStrings(strs ...string) string {
    var buf bytes.Buffer
    for _, s := range strs {
        buf.WriteString(s)
    }
    return buf.String()
}

func main() {
    s1 := "hello"
    s2 := "world"
    s3 := "!"
    s := concatStrings(s1, " ", s2, s3)
    fmt.Println(s) // 输出：hello world!
}

待确定：扩容是否影响效率？

# 9.5 格式化输出

在输出格式化的字符串时，可以使用 fmt.Sprintf 函数，也可以使用 Buffer 类型。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


package main

import (
    "bytes"
    "fmt"
)

func main() {
    var buf bytes.Buffer
    for i := 0; i < 10; i++ {
        fmt.Fprintf(&buf, "%d", i)
    }
    fmt.Println(buf.String())  // 输出0123456789
    fmt.Printf("len = %d, cap = %d\n", buf.Len(), buf.Cap()) // 输出len = 10, cap = 64
}

待确认：这里的cap输出为是什么是64？

# 9.6 图像处理

在图像处理中，我们经常需要将多个图像合成一个新的图像。使用 Buffer 类型可以方便地缓存多个图像的像素值，然后将它们从上到上连接合成为一个新的图像。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


package main

import (
        "fmt"
        "image"
        "image/png"
        "os"
)

func combineImages(images []image.Image) image.Image {
        width := images[0].Bounds().Dx()
        height := images[0].Bounds().Dy() * len(images)
        canvas := image.NewRGBA(image.Rect(0, 0, width, height))
        var y int
        for _, img := range images {
                for i := 0; i < img.Bounds().Dy(); i++ {
                        for j := 0; j < img.Bounds().Dx(); j++ {
                                canvas.Set(j, y+i, img.At(j, i))
                        }
                }
                y += img.Bounds().Dy()
        }
        return canvas
}

func main() {
        images := make([]image.Image, 3)
        for i := 0; i < 3; i++ {
                f, _ := os.Open(fmt.Sprintf("image%d.png", i+1))
                img, _ := png.Decode(f)
                images[i] = img
        }
        combined := combineImages(images)
        f, _ := os.Create("combined.png")
        png.Encode(f, combined)
}

在上面的示例中，我们使用 Buffer 类型缓存多个图像的像素值，并将它们合成为一个新的图像。使用 Buffer 类型可以方便地缓存像素值，同时也可以减少系统调用的次数，提高程序的效率。

# 10、总结

除了 bytes.Buffer 类型之外，Go 语言中还有 bytes.Reader 和 bytes.Writer 类型，它们都是基于 bytes.Buffer 类型实现的，可以用于读取和写入数据，但 bytes.Reader 类型只能读取数据，而 bytes.Writer 类型只能写入数据。在实际开发中，我们可以根据不同的需求来选择不同的类型。

在前文中留下几个问题，留待后续验证：

扩容、拼接的性能或效率情况
bytes.Buffer在不同应用场景下的初始容量为什么不同

参考：看完这篇文章，你就会知道 Go 中 Buffer 到底有什么用 - 掘金 (juejin.cn)

# 1、bytes.Buffer简介

# 2、创建bytes.Buffer

# 2.1 使用 NewBuffer() 函数创建

# 2.2 使用 bytes.Buffer 结构体创建