Go语言文件分块处理：优化字节切片大小以避免冗余

package main

import (
    "fmt"
    "io"
    "os"
)

// 定义文件块和文件块集合的类型
type (
    fileChunk  []byte
    fileChunks []fileChunk
)

// NumChunks 计算文件所需的块数
// 根据文件大小和块大小计算总块数，如果存在余数，则额外增加一个块。
func NumChunks(fi os.FileInfo, chunkSize int) int {
    chunks := fi.Size() / int64(chunkSize)
    if rem := fi.Size() % int64(chunkSize) != 0; rem {
        chunks++
    }
    return int(chunks)
}

// chunker 函数用于将文件分割成块。
// 该版本存在对最后一个不完整块的切片长度处理问题。
func chunker(filePtr *string) (fileChunks, error) {
    f, err := os.Open(*filePtr)
    if err != nil {
        return nil, fmt.Errorf("打开文件失败: %w", err)
    }
    defer f.Close()

    fileChunksContainer := make(fileChunks, 0)

    fi, err := f.Stat()
    if err != nil {
        return nil, fmt.Errorf("获取文件信息失败: %w", err)
    }
    fmt.Printf("文件名: %s, 文件大小: %d 字节\n", fi.Name(), fi.Size())

    chunkSize := 10000 // 假设每个块大小为 10000 字节
    chunksNeeded := NumChunks(fi, chunkSize)

    fmt.Printf("文件需要 %d 个块\n", chunksNeeded)

    for i := 0; i < chunksNeeded; i++ {
        // 为每个块分配固定大小的字节切片。
        // 问题在于，即使实际读取的字节数少于 chunkSize，切片的长度仍然是 chunkSize。
        b := make(fileChunk, chunkSize) 

        n1, err := f.Read(b)
        if err != nil && err != io.EOF {
            return nil, fmt.Errorf("读取文件块失败: %w", err)
        }
        if n1 == 0 && err == io.EOF { // 文件已读完，且没有数据读取
            break 
        }

        fmt.Printf("块: %d, 读取了 %d 字节\n", i, n1)

        // 将块添加到容器。
        // 如果 n1 < chunkSize，则 b 内部会包含零值填充。
        fileChunksContainer = append(fileChunksContainer, b)
    }

    fmt.Printf("最终文件块数量: %d\n", len(fileChunksContainer))

    return fileChunksContainer, nil
}

// 核心优化点：在读取操作后，根据实际读取的字节数 n1 重新切片。
n1, err := f.Read(b)
if err != nil {
    if err == io.EOF { // 达到文件末尾，可能已经读取了部分数据
        if n1 > 0 { // 如果读取了数据，则处理这部分数据
            b = b[:n1] // 重新切片，精确到实际读取的字节数
            // ... 然后