Go SectionReader 为什么读取范围不会越过上限

io.SectionReader 不会把读取请求直接原样交给底层数据源。创建时，它把 off 记为分段起点 base，把逻辑末尾记为 limit；每次 Read 前都会比较当前位置与 limit，必要时把缓冲区裁到“剩余字节数”。所以即使调用方传入很大的 []byte，底层 ReadAt 也只会收到分段内的那一小段。

官方文档：https://pkg.go.dev/io

SectionReader 把底层数据切成独立窗口

假设底层内容是 HEAD|PAYLOAD|TAIL，从偏移 5 开始取 7 个字节，窗口里只有 PAYLOAD。调用方看到的是一个长度为 7 的 Reader，而不是整段源数据：

package main

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

func main() {
	source := bytes.NewReader([]byte("HEAD|PAYLOAD|TAIL"))

	// 从底层偏移 5 开始，只暴露后续 7 个字节。
	section := io.NewSectionReader(source, 5, 7)
	data, err := io.ReadAll(section)
	if err != nil {
		panic(err)
	}

	// 结果只包含 PAYLOAD，不会继续读到后面的分隔符和 TAIL。
	fmt.Println(string(data))
}

这里的 Size() 返回 7。SectionReader 实现了 Read、ReadAt 和 Seek，因此同一个逻辑窗口既能顺序读取，也能按分段内部位置随机读取。

Read 会先把缓冲区裁到剩余长度

官方实现的关键判断很短：当前位置 s.off 已经大于或等于 s.limit 时，直接返回 0, io.EOF；否则计算 limit - off。如果传入缓冲区更大，就把 p 缩成剩余长度，再调用底层 ReadAt。

func readSectionOnce(section *io.SectionReader) ([]byte, error) {
	// 缓冲区故意大于分段，SectionReader 会在内部限制实际读取范围。
	buf := make([]byte, 32)
	n, err := section.Read(buf)

	// Reader 允许在 n 大于 0 时同时返回错误，必须先处理有效字节。
	data := append([]byte(nil), buf[:n]...)
	if err != nil && err != io.EOF {
		return data, err
	}
	return data, nil
}

核对点是：读取上限由 SectionReader 的内部 limit 决定，而不是由缓冲区容量决定。读到末尾后再次调用 Read，才稳定得到 0, io.EOF。

ReadAt 的 off 是分段内坐标

SectionReader.ReadAt(p, off) 先检查 off 是否落在 [0, Size()) 内，再把它加到 base 上，换算为底层 ReaderAt 的绝对偏移。若缓冲区从这个位置开始会跨过 limit，它同样会裁短，并为这次不完整读取返回 EOF。

func readTail(section *io.SectionReader) ([]byte, error) {
	buf := make([]byte, 4)

	// 从分段内部偏移 5 开始，7 字节窗口只剩最后 2 字节。
	n, err := section.ReadAt(buf, 5)
	data := append([]byte(nil), buf[:n]...)

	// 跨过分段末尾属于预期短读：保留已读数据，同时接受 EOF。
	if err != nil && err != io.EOF {
		return nil, err
	}
	return data, nil
}

这个例子请求 4 个字节，但窗口只剩 2 个字节，因此最多返回 AD，并伴随 EOF。需要注意，ReadAt 不改变顺序读取使用的当前位置；它适合在同一分段里读取固定字段。

Seek 能越过末尾，但 Read 仍不会越界

一个容易误解的点是：SectionReader 的 Seek 会拒绝落到分段起点之前的位置，但允许把当前位置设到分段末尾之后。这不代表后续能读取窗口外的数据，因为 Read 看到 off >= limit 后仍会立即返回 EOF。

func seekPastEnd(section *io.SectionReader) error {
	// 允许把逻辑位置设到分段末尾之后；返回位置仍按分段起点计算。
	if _, err := section.Seek(100, io.SeekStart); err != nil {
		return err
	}

	buf := make([]byte, 8)
	n, err := section.Read(buf)
	// 超过 limit 后应当没有数据，并以 EOF 表示窗口结束。
	if n != 0 || err != io.EOF {
		return fmt.Errorf("unexpected boundary result: n=%d err=%v", n, err)
	}
	return nil
}

SeekEnd 的基准是分段 limit，不是底层文件末尾。相反，若尝试从 SeekStart 传入负偏移并落到 base 之前，Seek 会返回错误。

还有哪些边界需要调用方负责

范围限制只解决“不能读过逻辑上限”，并不验证分段声明是否可信。解析文件格式时，仍应先检查 off、n 与实际文件大小的关系，也要处理底层 ReaderAt 提前返回 EOF 的情况。

用边界测试固定预期

func TestSectionReaderBounds(t *testing.T) {
	section := io.NewSectionReader(
		bytes.NewReader([]byte("HEAD|PAYLOAD|TAIL")),
		5,
		7,
	)

	// 大缓冲区只能得到窗口内的 7 个字节。
	buf := make([]byte, 32)
	n, err := section.Read(buf)
	if err != nil || string(buf[:n]) != "PAYLOAD" {
		t.Fatalf("unexpected first read: n=%d err=%v data=%q", n, err, buf[:n])
	}

	// 再读时已经位于 limit，必须返回 EOF。
	n, err = section.Read(buf)
	if n != 0 || err != io.EOF {
		t.Fatalf("unexpected end read: n=%d err=%v", n, err)
	}

	// ReadAt 的位置等于 Size 时已经在窗口外。
	n, err = section.ReadAt(buf[:1], section.Size())
	if n != 0 || err != io.EOF {
		t.Fatalf("unexpected ReadAt boundary: n=%d err=%v", n, err)
	}
}

这组测试不依赖底层文件游标，只检查 SectionReader 对逻辑窗口的承诺：数据最多来自 [base, limit)，当前位置到达 limit 后停止。

相关问题

SectionReader 和 LimitReader 有什么区别？

LimitReader 只包装 Reader 并按剩余字节数限制顺序读取；SectionReader 基于 ReaderAt 建立固定分段，同时提供 Read、ReadAt、Seek 和 Size。

ReadAt 越界为什么会返回部分数据和 EOF？

因为请求起点仍在窗口内，只是缓冲区跨过末尾。调用方应先处理 n 个有效字节，再判断 EOF。

Size 能证明底层一定有这么多字节吗？

不能。Size 表示 SectionReader 的逻辑窗口大小；如果底层数据提前结束，读取仍会返回底层错误或 EOF。