Go bytes.Buffer.String 取到的字符串会跟着缓冲区变化吗

bytes.Buffer.String() 返回调用时缓冲区“未读部分”的字符串。已经取出的 string 不会随着后续 Write、Read 或 Reset 自动变化；如果要拿到修改后的内容，需要再次调用 String()。容易混淆的是 Bytes() 返回的是与缓冲区关联的字节切片，两者的生命周期和修改规则不同。

Go 官方文档：https://pkg.go.dev/bytes#Buffer.String

把 String() 当作“当前未读内容的 string 快照”最容易记忆；把 Bytes() 当作“短期有效的别名切片”。需要持续保存文本时选 String，需要原地处理字节时才考虑 Bytes。

String 取的是哪一段内容

bytes.Buffer 既能写入，也能被当作读取器使用。读取发生后，缓冲区内部会推进未读位置，因此 String() 返回的不是最初写入过的全部字节，而是调用时仍未读取的那一段。

下面的示例只突出调用关系：第一次调用在读取前拿到完整文本，读取一个字节后再次调用，只能看到剩余内容。代码中的注释说明了边界和错误处理；示例输出应按输入和读取动作推导，不把它当作本机运行截图。

package main

import (
    "bytes"
    "fmt"
)

func main() {
    var buf bytes.Buffer
    // 写入后，缓冲区的未读部分就是完整的 "go-buffer"。
    buf.WriteString("go-buffer")
    fmt.Println(buf.String())

    one, err := buf.ReadByte()
    if err != nil {
        // 读取失败时不要把 one 当作有效数据继续处理。
        fmt.Println("读取失败:", err)
        return
    }

    // ReadByte 推进未读位置，所以这次 String 不再包含首字节。
    fmt.Printf("已读=%q，剩余=%q\n", one, buf.String())
}

这里要特别记住“未读部分”三个字：Read、ReadByte、Next 等读取方法都可能改变下一次 String() 的结果。Len() 也对应未读字节数量，而不是这个 Buffer 从创建以来累计写入的总量。

后续 Write 和 Reset 会不会改掉已经取出的 string

不会。Go 的 string 值不可变，String() 得到的结果可以独立保存。缓冲区之后继续写入、读取或重置，只会影响 Buffer 当前的未读内容，不会回写已经存在的 string 变量。

func snapshotThenModify() (string, string) {
    var buf bytes.Buffer
    // 第一次快照只包含当前未读内容。
    buf.WriteString("first")
    before := buf.String()

    // Write 改变 Buffer；它不会修改已经创建的 before。
    buf.WriteString("-second")
    afterWrite := buf.String()

    // Reset 清空未读内容，但 before 和 afterWrite 仍是普通 string 值。
    buf.Reset()
    return before, afterWrite
}

func readBeforeString(buf *bytes.Buffer) string {
    // 先读取再取 String，得到的是读取动作之后的剩余内容。
    if _, err := buf.ReadByte(); err != nil {
        return ""
    }
    return buf.String()
}

如果业务需要的是“每次读取 Buffer 的最新文本”，就把 String() 放在读取或写入动作之后重新调用；如果业务需要的是某个时点的内容，就把返回值保存下来。不要期待旧变量随着 Buffer 变化，那会让日志、缓存键或签名输入产生难以定位的时点差异。

不要把 Bytes 和 String 当成同一种返回值

Bytes() 返回的是未读部分的切片，并且会与 Buffer 的底层内容产生别名关系。官方文档明确说明，这个切片只在下一次 Buffer 修改前有效；直接改切片也可能影响后续读取。因此它适合“马上解析、马上消费”的短路径，不适合作为长期缓存。

func inspectBytes(buf *bytes.Buffer) ([]byte, error) {
    view := buf.Bytes()
    if len(view) == 0 {
        // 空视图代表当前没有未读数据，不等于 Buffer 曾经没有写入过。
        return nil, fmt.Errorf("没有可查看的未读字节")
    }

    // 这里的 view 只在下一次 Buffer 修改前使用，不能跨越 Write 或 Reset 保存。
    first := append([]byte(nil), view[0])
    _ = first
    return view, nil
}

func stableText(buf *bytes.Buffer) string {
    // 需要跨越后续 Buffer 修改保存时，直接取 string 快照。
    return buf.String()
}

上面的 append 只演示如何复制一个字节到独立切片；如果要完整保存 Bytes() 的内容，应使用 bytes.Clone(view) 或 append([]byte(nil), view...)。若最终目标是文本，直接使用 String() 更能表达意图。

什么时候应该改用 strings.Builder

bytes.Buffer 的优势是同时实现了字节缓冲和多个 io.Reader、io.Writer 相关能力；如果任务只是拼接字符串，strings.Builder 的表达更直接，官方文档也把它列为构建字符串的选择。二者都能写入，但不要因为都有 String() 就把它们的用途混为一谈。

func buildName(prefix, value string) string {
    var builder strings.Builder
    // Grow 只预留容量，不改变字符串内容；容量估算不准确也不会改变语义。
    builder.Grow(len(prefix) + len(value) + 1)
    builder.WriteString(prefix)
    builder.WriteByte(':')
    builder.WriteString(value)
    return builder.String()
}

这段代码需要在文件顶部导入 strings。选型可以按下面的边界判断：

• 需要读取、写入或在字节层处理：使用 bytes.Buffer。
• 只是在循环中构建最终字符串：优先使用 strings.Builder。
• 需要当前未读字节的短期视图：使用 Bytes()，并在下一次 Buffer 修改前消费。
• 需要保存某个时点的文本：使用 String()，不要保存 Bytes() 的别名。

相关问题

调用 String 会清空 bytes.Buffer 吗？

不会。String() 只是读取当前未读部分，不推进读取位置；只有读取方法或显式修改才会改变 Buffer 的状态。

为什么 String 之后再 Write，旧变量没有新内容？

因为旧变量已经是一个 string 值。想拿新内容时重新调用 String()，不要把它当成指向 Buffer 的动态引用。

Bytes 返回的切片能长期保存吗？

不建议。它只在下一次 Buffer 修改前有效，并且可能与底层存储别名；需要长期保存时先复制，或直接保存 String() 的结果。

nil 的 *bytes.Buffer 调用 String 会怎样？

官方文档规定，nil 指针接收者调用 String() 返回 ""。但业务代码仍应明确 nil 是否代表异常，避免把诊断文本当成正常数据。

参考规范：https://go.dev/ref/spec#String_types