Go io.SectionReader Outer 怎么还原底层读取区间

在文件分片、对象存储范围读取或大文件解析中，经常会把一个 io.SectionReader 再交给另一个 io.SectionReader。这时调用最外层的 Outer()，拿到的不是“最初文件的绝对区间”，而是创建当前窗口时传入的直接父对象、相对偏移和长度。

还原最终区间的规则很简单：先把每一层的相对偏移相加，再用父窗口的剩余长度限制子窗口。Go 官方文档说明，Outer 返回的三项值与创建该对象时传给 NewSectionReader 的值相同；这个方法从 Go 1.22.0 开始提供。

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

Outer 返回的是当前窗口的直接来源

SectionReader 实现了 Read、Seek 和 ReadAt，它把一个 ReaderAt 限制在指定的偏移和长度内。Outer() 的返回值可以理解为“当前窗口的构造参数快照”：r 是直接底层 ReaderAt，off 是相对这个 r 的起点，n 是当前窗口长度。

例如下面的三层关系中，child.Outer() 返回的是 parent、4、8，不会直接返回字符串读取器：

package main

import (
    "fmt"
    "io"
    "strings"
)

func main() {
    source := strings.NewReader("0123456789abcdefghijklmnopqrstuvwxyz")
    parent := io.NewSectionReader(source, 10, 20) // 父窗口对应 source[10:30]。
    child := io.NewSectionReader(parent, 4, 8)    // 子窗口从父窗口的相对位置 4 开始。

    r, off, n := child.Outer()
    // 这里只能看到直接父对象和子窗口参数，不能把 off 当成 source 的绝对偏移。
    fmt.Printf("%T off=%d n=%d\\n", r, off, n)
}

这里的绝对起点是 10 + 4 = 14。不过，Outer 不会替你完成这个加法，也不会递归拆开任意实现的 ReaderAt；调用方需要在知道对象确实是 *io.SectionReader 时自行继续展开。

用嵌套窗口推导绝对起点和有效长度

假设父窗口从底层起点 P 开始、长度为 Np，子窗口相对父窗口的偏移是 C、请求长度是 Nc，那么子窗口在底层的起点是 P + C。长度不能简单照抄 Nc，因为父窗口剩余空间只有 Np - C；安全的有效长度是两者的较小值。

用具体数字看更直观：父窗口是底层的 [10, 30)，子窗口是父窗口的 [4, 12)，所以最终范围是底层的 [14, 22)。如果子窗口请求父窗口的 [18, 28)，它的起点仍是 28，但父窗口只剩 2 个字节，真正可读长度应当截成 2。

这也是为什么只累加偏移而不截断长度会留下隐患：下游如果拿还原后的长度生成 HTTP Range、文件导出任务或并发分片，就可能误以为区间外数据仍然属于当前窗口。

封装一个逐层还原函数

下面的函数把最外层 *io.SectionReader 还原到最底层的 io.ReaderAt。循环每次检查直接父对象是否仍然是 *io.SectionReader；如果是，就把当前偏移加上父偏移，并按父窗口剩余长度收窄当前长度。

package rangeutil

import (
    "fmt"
    "io"
)

// FlattenSection 返回底层 ReaderAt、绝对起点和不会越过父窗口的有效长度。
func FlattenSection(section *io.SectionReader) (io.ReaderAt, int64, int64, error) {
    r, off, n := section.Outer()

    for {
        parent, ok := r.(*io.SectionReader)
        if !ok {
            // 已经到达普通 ReaderAt，off 此时就是相对它的绝对起点。
            return r, off, n, nil
        }

        parentReader, parentOff, parentN := parent.Outer()
        relativeOff := off
        if relativeOff  available {
            // 只把父窗口剩余的部分交给下游，避免扩大可读范围。
            n = available
        }

        off = parentOff + relativeOff
        r = parentReader
    }
}

这个实现的关键不是类型断言本身，而是每次循环都同时维护三件事：当前 ReaderAt、相对于它的偏移，以及当前仍然有效的长度。只有三者一起更新，结果才不会出现“起点已经落到底层、长度却还停留在子窗口”的错配。

ReadAt、Size 和 Outer 的职责不要混用

还原区间时，三个 API 的职责不同：

如果只是读取当前窗口，不需要调用 Outer。直接使用 Read 或 ReadAt 更简单，边界也由 SectionReader 负责。只有在需要把范围交给分片调度器、记录元数据、构造下游范围请求或合并相邻窗口时，才有必要做逐层还原。

此外，ReadAt 的偏移是相对接收者的，而不是相对最初底层对象的。下面的 ReadAt(buf, 0) 读取的是 child 窗口的第一个字节，不是底层数据的第一个字节：

buf := make([]byte, 4)
n, err := child.ReadAt(buf, 0) // 0 是 child 窗口内的相对偏移。
if err != nil && err != io.EOF {
    // 先处理已读出的 n 个字节，再处理非 EOF 错误。
    return fmt.Errorf("read section: %w", err)
}
_ = n

把还原结果交给下游前的四个检查点

在生成文件导出范围、对象存储请求或并发分片任务前，可以固定检查下面四项：

1. 确认使用的是同一个底层 ReaderAt，不要把某一层的相对偏移直接写入全局元数据。
2. 偏移累加时使用 int64，并在业务允许的情况下检查加法溢出。
3. 长度使用父窗口剩余空间和子窗口请求长度的较小值，不根据用户输入扩大范围。
4. 如果结果长度为零，直接让任务返回空范围或明确错误，不向下游发起无意义的读取。

还要注意，普通 io.ReaderAt 不一定能被反射出“内部区间”。只有明确拿到 *io.SectionReader 时，才能调用它的 Outer。对自定义包装器应通过自己的元数据接口传递范围，不能假设所有 ReaderAt 都支持同样的还原方式。

常见问题

Outer 会返回最初的文件对象吗？

不一定。它返回创建当前 SectionReader 时传入的直接 ReaderAt。如果这个对象本身也是 SectionReader，就需要继续逐层调用。

为什么不能只把每层长度相加？

长度不是偏移。嵌套窗口的可读范围受每一层父窗口限制，子窗口越过父窗口时必须截断，而不是把请求长度带到最底层。

只想读取数据时需要 FlattenSection 吗？

不需要。直接使用最外层 SectionReader 即可；FlattenSection 适合需要把底层范围交给其它组件、记录或调度的场景。