io.NewSectionReader 组合校验和分片读取

读取大文件的一段字节时，直接对原文件调用 Read 很容易把“本片应该读多少”交给调用方自己维护。更稳妥的做法是先用 io.NewSectionReader 固定区间，再把这个分片阅读器交给 io.TeeReader：一条读取路径写入输出流，另一条路径计算 SHA-256。

先理解 io.NewSectionReader 的区间语义

NewSectionReader 的第一个参数是 io.ReaderAt，第二个参数 off 是底层数据的起始偏移，第三个参数 n 是这个分片允许读取的最大字节数。返回的 *io.SectionReader 实现了 Read、ReadAt、Seek 和 Size。

可以把它看成底层文件上的一个窗口：窗口从 off 开始，长度是 n，读取到窗口末尾就结束。它不会把文件内容复制到新的缓冲区，因此适合把大文件拆成多个逻辑分片。

用 TeeReader 同时输出分片并计算校验和

校验和的关键不是先把分片读进 []byte，而是让实际读取经过一个旁路写入器。下面的函数把分片写入 dst，同时计算 SHA-256，并用返回的字节数判断是否真的读完了预期长度。

package main

import (
    "crypto/sha256"
    "encoding/hex"
    "fmt"
    "io"
)

// copySection 输出指定区间，并在同一趟读取中计算 SHA-256。
func copySection(dst io.Writer, src io.ReaderAt, off, size int64) (int64, string, error) {
    // SectionReader 将读取范围固定为 [off, off+size)，避免读到下一片。
    section := io.NewSectionReader(src, off, size)

    // TeeReader 把读到的每个字节同步写给哈希对象，不保存整片内容。
    digest := sha256.New()
    tee := io.TeeReader(section, digest)

    // Copy 返回实际写入数量；它遇到分片末尾的 EOF 时会正常结束。
    written, err := io.Copy(dst, tee)
    if err != nil {
        return written, "", fmt.Errorf("copy section: %w", err)
    }
    if written != size {
        // 文件被截短或 ReaderAt 提前结束时，不能把短片当成完整分片。
        return written, "", io.ErrUnexpectedEOF
    }

    return written, hex.EncodeToString(digest.Sum(nil)), nil
}

这个组合的读取顺序是：SectionReader 限制范围，TeeReader 把读取到的数据交给哈希对象，io.Copy 把同一批数据写到目标流。任何一步返回错误，都应该停止使用当前分片的校验结果。

构造分片前先做四项边界检查

NewSectionReader 的参数本身没有返回错误的位置，所以业务层要在调用前验证。对已知文件大小 size，最实用的条件是把“剩余长度”写成 size-off，这样可以避免直接计算 off+n 时的溢出风险。

package main

import (
    "fmt"
    "io"
)

// validateRange 确保分片完全落在 [0, fileSize) 内。
func validateRange(fileSize, off, length int64) error {
    // 偏移和长度都不允许为负数。
    if fileSize  fileSize {
        return fmt.Errorf("offset %d exceeds file size %d", off, fileSize)
    }
    // 先做减法得到剩余范围，再比较长度，避免 off+length 溢出。
    if length > fileSize-off {
        return fmt.Errorf("range [%d, %d) exceeds file size %d", off, off+length, fileSize)
    }
    return nil
}

// newCheckedSection 只在边界合法时创建 SectionReader。
func newCheckedSection(src io.ReaderAt, fileSize, off, length int64) (*io.SectionReader, error) {
    if err := validateRange(fileSize, off, length); err != nil {
        return nil, err
    }
    return io.NewSectionReader(src, off, length), nil
}

上面的错误信息里保留了范围表达式，便于日志定位；生产代码也可以先判断再格式化，避免极端整数输入时只为错误文本再次做加法。核心判断始终是 length 。

把大文件拆成互不重叠的分片

当文件大小为 fileSize、每片目标长度为 chunkSize 时，可以让下一片的偏移等于上一片的结束位置。每个分片都单独创建 SectionReader，这样一个分片提前结束不会改变其他分片的起点。

package main

import (
    "crypto/sha256"
    "encoding/hex"
    "fmt"
    "io"
)

// shard 描述一片文件的绝对偏移和长度。
type shard struct {
    offset int64
    length int64
}

// planShards 按固定大小生成不重叠的分片计划。
func planShards(fileSize, chunkSize int64) ([]shard, error) {
    if fileSize 

这里的分片计划只负责“从哪里读、读多长”，校验函数负责“读到多少、摘要是什么”。如果后续要并发处理，仍然要给每个分片配独立的输出文件和哈希对象，不能多个任务共享同一个可变写入状态。

Read、ReadAt 和 EOF 应该怎样判断

通过 Read 顺序消费 SectionReader 时，读到指定长度后自然会遇到 io.EOF。用 io.Copy 时，这个 EOF 是正常收尾信号；但如果总字节数小于预期长度，就应该返回 io.ErrUnexpectedEOF，否则上层会把残缺分片当成完整分片。

SectionReader.ReadAt 的偏移是相对于当前分片起点，而不是整个文件起点。例如创建 io.NewSectionReader(file, 1000, 500) 后，ReadAt(buf, 0) 读取的是文件偏移 1000 的位置。需要随机访问多个小范围时，这种相对坐标可以让调用方不再重复计算全局偏移。

常见问题

io.NewSectionReader 能接普通的 io.Reader 吗？

不能直接接收。它需要 io.ReaderAt，因为分片要从指定绝对偏移开始读取。文件、字节字符串读取器等类型通常可以提供这个接口；只有顺序流时，应在更上层设计分片协议，不能假设可以随时回到任意偏移。

为什么不先 io.ReadAll 再计算哈希？

小数据可以这样做，但大文件分片会额外占用与分片长度相关的内存。io.TeeReader 配合 io.Copy 可以流式处理，内存主要由复制缓冲区决定。

分片末尾返回 EOF 是错误吗？

如果实际读取数量等于期望长度，io.Copy 消费到分片边界后的 EOF 属于正常结束；如果数量不足，应该把它升级为 io.ErrUnexpectedEOF，让调用方知道文件或底层读取过程不完整。

多个 goroutine 可以共享同一个 SectionReader 吗？

不要依赖共享同一个实例的游标。并发任务应为每个分片创建独立的 SectionReader，并确认底层 ReaderAt 的并发使用约束；输出目标和哈希对象也要隔离。

小结

io.NewSectionReader 负责把“只能读这一段”变成一个明确的阅读器，io.TeeReader 则把同一次读取分成输出和校验两条路径。把边界检查、实际字节数和 io.ErrUnexpectedEOF 一起处理，就能在不读入整片内容的情况下完成可靠的分片读取与 SHA-256 校验。