bytes.Reader 怎么用 Seek 重放内存数据

用 bytes.Reader 重放内存数据，核心就是把下一次读取的位置改回目标偏移：回到开头使用 Seek(0, io.SeekStart)，相对当前位置移动使用 io.SeekCurrent，从尾部计算位置使用 io.SeekEnd。Seek 返回的是相对于数据开头的新偏移，先检查这个返回值和错误，再继续读取即可。

官方文档：https://pkg.go.dev/bytes#Reader

本文只讨论内存中的 []byte、Reader 当前位置、Seek 和 EOF，不把它延伸成随机文件读写教程。

先弄清 bytes.Reader 保存了什么状态

bytes.NewReader(data) 创建的是一个只读 Reader。它引用给定的字节切片，并保存一个当前位置；每次成功的 Read 都会让当前位置向后移动。当前位置不是数据本身的一部分，所以重放时不需要重新复制原始切片，只需调整偏移。

Len() 返回当前位置之后尚未读取的字节数，Size() 返回底层切片的原始长度。两者不要混用：前者会随着读取和 Seek 改变，后者只在 Reset 后才会改变。

三种 Seek 基准分别怎样计算

io.Seeker 的接口只有一个方法：

Seek(offset int64, whence int) (int64, error)

关键在第二个参数。io.SeekStart 把偏移当作从数据开头算起，io.SeekCurrent 从当前位置算起，io.SeekEnd 从数据末尾算起。成功后返回新位置，例如从开头向后跳 3 个字节就使用 Seek(3, io.SeekStart)。

package main

import (
	"bytes"
	"fmt"
	"io"
)

func main() {
	data := []byte("abcdef")
	r := bytes.NewReader(data)

	// 从数据开头定位到下标 2，下一次 Read 会从 'c' 开始。
	pos, err := r.Seek(2, io.SeekStart)
	if err != nil {
		panic(err)
	}
	fmt.Println(pos, r.Len())

	// 相对当前位置向后移动一个字节，读取位置变成下标 3。
	pos, err = r.Seek(1, io.SeekCurrent)
	if err != nil {
		panic(err)
	}
	fmt.Println(pos, r.Len())

	// 从末尾向前退两个字节，读取位置变成下标 4。
	pos, err = r.Seek(-2, io.SeekEnd)
	if err != nil {
		panic(err)
	}
	fmt.Println(pos, r.Len())
}

这里的偏移都是字节偏移，不是 UTF-8 字符数。若数据包含多字节中文，Seek(1, io.SeekStart) 可能落在一个字符的中间；后续把它当字符串解码时，要由上层决定是否允许这种切分。

重放数据时直接 Seek 回开头

最常用的重放模式是：读完一段数据后，将 Reader 调回 0，再让下一段逻辑从开头重新读。Seek 返回的偏移应当保存或检查，避免把一个已经失败的定位当成成功。

package main

import (
	"bytes"
	"fmt"
	"io"
)

func readAllOnce(r *bytes.Reader) (string, error) {
	buf := make([]byte, 3)
	var out []byte
	for {
		n, err := r.Read(buf)
		// 只追加本次真正读到的字节，避免复用缓冲区时带入旧内容。
		out = append(out, buf[:n]...)
		if err == io.EOF {
			return string(out), nil
		}
		if err != nil {
			return "", err
		}
	}
}

func main() {
	r := bytes.NewReader([]byte("go-seek"))

	first, err := readAllOnce(r)
	if err != nil {
		panic(err)
	}

	// 把下一次读取位置重置到数据开头，复用同一个 Reader。
	pos, err := r.Seek(0, io.SeekStart)
	if err != nil {
		panic(err)
	}
	if pos != 0 {
		panic("unexpected reader offset")
	}

	second, err := readAllOnce(r)
	if err != nil {
		panic(err)
	}
	fmt.Println(first == second, first, second)
}

这个模式只改变 Reader 的游标，不改变底层 []byte。如果多个 goroutine 同时读同一个 Reader，当前位置会被共享，结果也会互相影响；需要并发处理时，应为每个消费者创建独立 Reader，或在外层明确同步。

EOF、Len 和越界定位怎么区分

“读不到数据”不总是同一种情况。当前位置等于数据长度时，Len() 为 0；继续读取通常会得到 io.EOF。这表示已经到达末尾，不等价于 Seek 失败。

相反，如果把位置向数据开头之前移动，Seek 会返回错误。向数据末尾之后定位在接口层面可能被允许，但后续读取不会凭空产生字节，因此固定长度协议仍然应该自己限制可读范围。

package main

import (
	"bytes"
	"fmt"
	"io"
)

func main() {
	r := bytes.NewReader([]byte("abc"))

	// 尝试落到起点之前，错误必须被处理，不能继续假设位置有效。
	if _, err := r.Seek(-1, io.SeekStart); err != nil {
		fmt.Println("seek error")
	}

	// 定位到末尾后，Len 为零；Read 的 EOF 是正常的结束信号。
	if _, err := r.Seek(0, io.SeekEnd); err != nil {
		panic(err)
	}
	buf := make([]byte, 1)
	n, err := r.Read(buf)
	fmt.Println(n, r.Len(), err == io.EOF)
}

循环读取时不要只写成“遇到任意错误就丢弃已读字节”。一个安全的顺序是先处理 n，再判断错误；某些 Reader 可能在同一次调用里返回部分数据和一个错误。

几个容易混淆的边界

结论：把 Seek 当成读取游标控制器

如果需求是重放整段内存数据，使用 Seek(0, io.SeekStart)；如果需求是从当前位置调整，使用 io.SeekCurrent；如果需求是从尾部定位，使用 io.SeekEnd。每次都检查返回的绝对偏移和错误，并用 Len() 判断剩余字节，用 io.EOF 判断自然结束。

这样写的好处是状态很明确：底层字节不变，变化的只是下一次 Read 的起点。只要把 Reader 的可变游标和并发边界管理好，内存数据的重复解析、协议预览和小型解码任务都可以复用这一套模型。

相关问题

bytes.Reader 和 bytes.Buffer 可以互换吗？

不能直接互换。bytes.Reader 适合只读和 Seek，bytes.Buffer 更偏向读写队列；是否需要回退读取位置，是选择类型时的重要区别。

为什么 Seek 的 offset 要用 int64？

因为 io.Seeker 的统一接口使用 int64 表示偏移，便于和文件、SectionReader 等其他可定位 Reader 组合；bytes.Reader 的实际长度仍受切片和平台内存限制。

用 ReadAt 能代替 Seek 重放吗？

如果每次读取都能明确给出绝对偏移，可以考虑 ReadAt；如果代码围绕“下一次从哪里继续读”的流式状态组织，Seek 更直观。两者不要在同一个 Reader 上混淆地维护两套位置概念。