Go slices.Chunk 怎么按固定大小遍历切片

在 Go 1.23 及以上版本里，把切片按固定大小遍历可以直接写成 for chunk := range slices.Chunk(items, size)。它返回的是 iter.Seq 迭代器，不会先替你构造一个完整的二维切片；除最后一块外，每块长度都是 size，最后一块可能更短。

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

这个 API 很适合批量写入、分批调用接口、分页构造参数等场景。不过，真正落地时还要处理四个边界：Go 版本、末尾短块、size 非法值，以及子切片与原切片共享存储。

一、准备 Go 1.23 以上环境

slices.Chunk 和函数迭代器的 for range 支持都在 Go 1.23 中加入。项目的工具链和 go.mod 至少要面向 Go 1.23，否则代码会因为标准库 API 或语法不可用而无法编译。

module example.com/chunkdemo

// Go 1.23 开始支持 slices.Chunk 与 range-over-function。
go 1.23

这里不需要安装第三方分块库，slices 和 iter 都属于标准库。示例代码只需导入 fmt 与 slices。

二、写出最小固定分块循环

先从一个最常见的任务开始：把 7 个任务 ID 按每组 3 个遍历。slices.Chunk 的第二个参数就是块大小，循环变量 chunk 每次拿到一个连续子切片。

package main

import (
    "fmt"
    "slices"
)

func main() {
    taskIDs := []int{101, 102, 103, 104, 105, 106, 107}
    const batchSize = 3

    // Chunk 返回 iter.Seq[[]int]，for range 每次取得一个子切片。
    for chunk := range slices.Chunk(taskIDs, batchSize) {
        fmt.Println(chunk)
    }
}

按这组输入的结构，预期会看到三块数据：

[101 102 103]
[104 105 106]
[107]

注意循环只有一个接收变量。Chunk 返回 iter.Seq[Slice]，不是带索引的 iter.Seq2。如果业务需要批次号，应自己维护计数器。

batchNo := 0

// Chunk 不产生索引，批次号由消费端维护。
for chunk := range slices.Chunk(taskIDs, 3) {
    batchNo++
    fmt.Printf("batch=%d values=%v\n", batchNo, chunk)
}

三、检查完整块和末尾短块

官方定义是“连续、最多包含 n 个元素的子切片”。因此，前面的完整块长度等于 n，只有最后一块允许不足。下游如果要求精确固定长度，不能假设每次都能拿到 n 个元素，应明确处理短块。

func consumeFixedBlocks(values []int, size int) {
    // 业务只接受完整块时，显式跳过最后的短块。
    for chunk := range slices.Chunk(values, size) {
        if len(chunk) != size {
            fmt.Printf("skip short chunk: %v\n", chunk)
            continue
        }
        fmt.Printf("consume full chunk: %v\n", chunk)
    }
}

是否跳过短块取决于业务，而不是 Chunk。批量写入通常应接收最后一块；只有协议明确要求定长帧时，才需要补齐、拒绝或单独处理。

四、处理空切片和非法大小

空输入不会产生“一个空块”，而是产生空序列，所以循环体一次也不会执行。这让批处理函数可以自然地把空任务视为无事可做。

empty := []string{}
count := 0

// 空切片对应空序列，循环体不会执行。
for chunk := range slices.Chunk(empty, 2) {
    count++
    fmt.Println(chunk)
}

fmt.Println("chunk count:", count)

块大小则必须大于等于 1。传入 0 或负数时，slices.Chunk 会直接 panic。对外部配置、请求参数或命令行输入，不要依赖 panic 作为参数校验。

func processInChunks(values []string, size int) error {
    // 在调用 Chunk 前把外部输入转换成普通错误。
    if size 

五、理解子切片容量与修改边界

Chunk 产出的是原切片的连续子切片，不会复制元素。对 chunk[i] 赋值，会修改共享底层数组，因此原切片也能观察到变化。

同时，标准库会把每个子切片的容量裁剪到其长度，也就是 cap(chunk) == len(chunk)。这个设计避免对某一块执行 append 时覆盖原切片中紧随其后的元素：因为没有剩余容量，append 需要扩展时会为结果分配新的底层存储。

numbers := []int{10, 20, 30, 40}

for chunk := range slices.Chunk(numbers, 2) {
    // 每个块的容量已裁剪到长度。
    fmt.Printf("chunk=%v len=%d cap=%d\n", chunk, len(chunk), cap(chunk))

    // 修改已有元素会反映到原切片，因为元素仍共享底层数组。
    chunk[0] *= 10

    // append 需要扩容，返回的新切片不会覆盖后一个块的元素。
    expanded := append(chunk, 999)
    fmt.Println("expanded:", expanded)
}

fmt.Println("original:", numbers)

如果下游会长期保存块、并发修改块，或你希望它完全脱离原切片，可以在交付前复制：

for chunk := range slices.Chunk(numbers, 2) {
    // Clone 创建独立副本，避免下游修改影响原始切片。
    owned := slices.Clone(chunk)
    saveForLater(owned)
}

六、按需中止或收集全部分块

迭代器的优势是按消费需求产出数据。找到目标块后可以直接 break，不用先构造全部分块：

for chunk := range slices.Chunk(taskIDs, 3) {
    // 找到包含目标任务的块后即可提前停止遍历。
    if slices.Contains(chunk, 105) {
        fmt.Println("found:", chunk)
        break
    }
}

如果某个 API 明确需要 [][]T，可以再用 slices.Collect 物化迭代器。这样写语义直接，但会额外创建保存各块切片头的外层切片。

// Collect 把 iter.Seq[[]int] 收集为 [][]int。
allChunks := slices.Collect(slices.Chunk(taskIDs, 3))
fmt.Println(allChunks)

选择标准很简单：逐块处理时直接 range；确实要随机访问、重复遍历或传给只接收二维切片的函数时再 Collect。

七、把分块用于批量任务

实际批处理不能只把数据分开，还应保留批次号和错误上下文。下面的写法遇到失败会立刻返回，并指出是哪一批出错：

func sendBatches(ids []int, size int, send func([]int) error) error {
    // 先校验 size，避免 Chunk 因非法参数 panic。
    if size 

如果要并发发送，不要因为分块后数量减少就无限创建 goroutine。仍应设置并发上限，并确认 send 不会修改共享块；需要跨 goroutine 长期持有数据时，优先 slices.Clone(chunk) 后再提交任务。

八、用清单核对常见误区

• 版本：slices.Chunk 需要 Go 1.23 或更高版本。
• 返回值：它返回 iter.Seq[Slice]，不是 [][]T；需要二维切片时使用 slices.Collect。
• 块长度：除最后一块外长度为 n，最后一块可能更短。
• 空输入：空切片不会产生空块，循环体执行零次。
• 非法参数：n 会 panic，外部输入应提前校验。
• 共享存储：修改块内已有元素会影响原切片；长期持有或并发修改时应复制。
• 容量裁剪：每块的容量等于长度，向块追加新元素不会覆盖后续块。

slices.Chunk 会复制切片元素吗？

不会。它产出原切片上的连续子切片，所以元素修改仍会反映到原切片。只有显式调用 slices.Clone 等复制操作，才能获得独立元素存储。

怎么获得每个块的起始下标？

Chunk 不直接返回索引。可以在消费端维护 batchNo，并用 start := batchNo * size 计算起点；如果中途跳过块或有其他规则，建议在循环中单独累计实际偏移量。

什么时候继续手写下标循环？

当你必须同时控制重叠窗口、动态步长、从中间偏移开始，或需要精确操作原始下标时，手写 for start := 0; start 仍然更清楚。对于“连续、互不重叠、固定最大大小”的普通分块，slices.Chunk 能减少边界计算和末尾截断代码。

归纳起来，固定分块的最小写法就是 for chunk := range slices.Chunk(s, n)。先保证 n > 0，接受最后一块可能变短，再根据是否修改、并发或长期保存决定要不要复制子切片，就能把这个 API 安全地用于实际批处理。