Go bytes.Buffer 的 UnreadByte 为什么会失败：读取游标、最后一个字节与复位时机

用 bytes.Buffer 解析一个简单协议时，常见写法是先读一个字节判断类型，再决定要不要把它交回后续解析。此时 UnreadByte 不是“把游标随便往前挪”，它只记得最近一次成功的单字节读取；如果中间做了不支持回退的操作，调用就会返回错误。

UnreadByte 通常只能紧跟在一次成功的 ReadByte 后使用一次。想重读同一个字节，就按“读取—回退—再次读取”配对；一旦发生第二次读取或调用 Reset，不要再假设旧游标还能回退。

先看一个能重现成功回退的最小例子

下面的代码把 ReadByte、UnreadByte 和再次读取放在相邻位置。输出中的两个字节都应为 G，因为第一次读取后，读取位置被退回到了这个字节之前。

package main

import (
    "bytes"
    "fmt"
)

func main() {
    var buf bytes.Buffer
    buf.WriteString("Go")

    first, err := buf.ReadByte()
    fmt.Printf("first=%q err=%v\n", first, err)

    err = buf.UnreadByte()
    fmt.Printf("unread err=%v\n", err)

    again, err := buf.ReadByte()
    fmt.Printf("again=%q err=%v\n", again, err)
}

判断结果时要同时看字节和错误。只有 err == nil 才说明读取或回退真的完成；不能因为拿到了一个看似合理的字符，就跳过错误检查。

UnreadByte 记住的是哪一次读取

bytes.Buffer 的回退语义适合做一个很窄的判断窗口：先读一个字节，检查它是不是分隔符或类型标记；如果发现它属于后续解析，就立即回退。回退成功后，下一次 ReadByte 才会重新读到同一个位置。

关键在“最近一次成功的单字节读取”。例如先调用一次 ReadByte 读出 G，再调用一次 ReadByte 读出 o，此时回退动作针对的是 o，不是前面的 G。如果协议需要回看多个字节，应改用显式索引或在更高层保存片段，不要连续堆叠 UnreadByte。

var buf bytes.Buffer
buf.WriteString("Go")

_, _ = buf.ReadByte() // G
last, err := buf.ReadByte() // o
if err != nil {
    panic(err)
}
if err := buf.UnreadByte(); err != nil {
    panic(err)
}
same, _ := buf.ReadByte()
fmt.Printf("last=%q same=%q\n", last, same)

这段程序的可见结果是 last='o' same='o'。回退发生在第二次成功读取之后，读取游标只回到 o 的位置。

连续回退为什么会失败

一次 UnreadByte 成功后，并不会产生一个可以无限消费的回退栈。紧接着再次调用时，前一个回退已经把最近一次读取标记消耗掉了，因此返回错误。这个错误必须被当作控制流的一部分处理。

var buf bytes.Buffer
buf.WriteString("A")

_, _ = buf.ReadByte()
firstErr := buf.UnreadByte()
secondErr := buf.UnreadByte()
fmt.Printf("first=%v second=%v\n", firstErr, secondErr)

在真实解析器里，第二次失败往往说明状态机写错了：代码以为自己保存了多个历史位置，但 bytes.Buffer 只提供最近一次单字节读取的回退窗口。更稳妥的写法是让每次回退都紧跟对应的成功读取，并在分支中明确谁拥有这个动作。

Read 和 Reset 会怎样改变边界

UnreadByte 的使用场景不能泛化到所有读取方法。若代码先用 Read 取出一段字节，再期待 UnreadByte 把整段内容还原，意图就已经超出这个方法的职责。需要恢复一段数据时，可以让上层保留切片，或重新构造一个新的 bytes.Buffer。

Reset 则是更明确的边界：它把缓冲区恢复为空，之前写入的数据不再可读。调用 Reset 后再执行 UnreadByte，不能把它理解为恢复旧数据；应先确认新一轮写入和读取是否已经开始。

var buf bytes.Buffer
buf.WriteString("old")
_, _ = buf.ReadByte()
buf.Reset()

err := buf.UnreadByte()
fmt.Printf("after reset unread=%v len=%d\n", err, buf.Len())

核对时看两个结果：Len() 应反映当前缓冲区为空，回退也不能让旧内容重新出现。若业务需要复用底层存储，复用的是容量，不是旧的读取语义。

把回退动作放进一个可验收的解析分支

一个实用边界是：只为“读一个字节决定后续路径”的场景使用 UnreadByte。下面的函数遇到 # 时消费它，遇到其他字节时退回，让后续逻辑从原位置继续。

func consumeMarker(buf *bytes.Buffer) (bool, error) {
    b, err := buf.ReadByte()
    if err != nil {
        return false, err
    }
    if b == '#' {
        return true, nil
    }
    if err := buf.UnreadByte(); err != nil {
        return false, err
    }
    return false, nil
}

调用方可以分别验收三种状态：空缓冲区返回读取错误；首字节是 # 时返回 true 且标记已消费；首字节不是 # 时返回 false，随后读取仍应得到原来的字节。这个分支把“谁消费标记、谁保留普通字节”写在代码里，比在多个函数之间共享一个隐含游标更容易维护。

相关问题

UnreadByte 能连续调用两次吗？

通常不能。一次成功回退后，下一次调用没有新的最近读取可供回退，应检查返回错误。

ReadRune 后能调用 UnreadByte 吗？

不要这样设计解析逻辑。UnreadByte 面向最近的单字节读取，读取方法不同会改变回退语义；需要回退字符时应使用匹配的方法或保存原始数据。

Reset 后怎样重新开始读取？

重新写入新数据，再从新一轮的 ReadByte 开始。旧数据和旧回退位置都不应作为新一轮状态。

小结

bytes.Buffer.UnreadByte 解决的是一次很具体的“读一个字节后反悔”问题。把它和最近一次成功的 ReadByte 紧密配对，检查每次返回错误，并在多字节回看或 Reset 场景改用显式状态，就能避免把单步回退误当成通用游标。