Go 怎样把切片按固定大小分块遍历

如果只是想把一组数据按固定数量分批处理，Go 1.23 起可以直接使用标准库 slices.Chunk。它返回一个迭代器，遍历时每次得到不超过指定大小的连续子切片；当元素数量不能整除块大小时，最后一块会自动变短。

官方地址：https://pkg.go.dev/slices

这篇只讨论分块视图和边界行为，不把数据预先组装成二维切片。对于逐批写入、分页处理或批量调用等一次性任务，这种方式更直接。

先确认任务负载：只需要逐块处理，还是要长期保存分块

slices.Chunk 适合“拿到一块、处理一块”的负载。它返回的是连续子切片视图，而不是把每个元素重新复制到新的二维容器中。因此，函数内部完成一轮批处理时，推荐直接 range；如果要把某一块交给异步任务或长期缓存，就要额外复制。

可以先用下面的规则选择实现：

用 slices.Chunk 按固定大小遍历

最小写法是传入原切片和块大小，然后用 for chunk := range ... 依次消费每个分块。下面的例子把 8 条记录按 3 条一批处理，所以会得到 3、3、2 三个分块。

package main

import (
    "fmt"
    "slices"
)

func main() {
    records := []string{"A", "B", "C", "D", "E", "F", "G", "H"}
    batchSize := 3

    // 每次只处理一个连续分块，不必先创建二维切片。
    for batchNo, chunk := range slices.Chunk(records, batchSize) {
        // 最后一块可能不足 batchSize，直接按实际长度处理。
        fmt.Printf("第 %d 批（%d 条）：%v\n", batchNo+1, len(chunk), chunk)
    }
}

这里的 batchNo 是从 0 开始的分块序号，chunk 的长度只保证“不超过 batchSize”。如果输入长度是 8、块大小是 3，最后一块的长度就是 2，不需要再写一个“剩余数量”分支。

推荐写法：把单批处理封装在函数里

真实业务通常不是打印分块，而是写入数据库、调用批量接口或生成一批消息。把单批处理抽成函数，可以让分块策略和业务动作分开，也更容易给空输入和失败返回值留出清晰位置。

package main

import (
    "fmt"
    "slices"
)

func processAll(items []string, batchSize int) error {
    if batchSize 

虽然 slices.Chunk 自身会在 batchSize 时 panic，但在业务边界上主动返回错误通常更容易定位配置问题。若块大小来自固定常量且已经由调用方保证为正数，可以省略这层检查。

子切片不是独立副本：异步场景要先复制

Chunk 产生的是原切片的连续子切片视图。同步读取通常没有问题，但不要默认它已经与原数据完全隔离。比如把 chunk 直接放入异步队列，生产者后续修改原切片时，后台任务可能仍然看到同一底层数组中的变化。

需要跨越当前处理生命周期时，可以用 slices.Clone 创建独立副本：

func enqueueBatches(items []string, batchSize int, enqueue func([]string) error) error {
    for chunk := range slices.Chunk(items, batchSize) {
        // 异步任务需要独立数据，避免持有原切片的底层数组。
        owned := slices.Clone(chunk)
        if err := enqueue(owned); err != nil {
            return err
        }
    }
    return nil
}

另外，官方实现会把每个子切片的容量限制到它自身长度，避免对分块执行 append 时意外覆盖相邻元素。但这不等于复制了元素；是否复制仍然要根据异步、缓存和所有权边界来决定。

三个边界必须记住：尾块、空输入和 n 小于 1

尾块不足固定大小：这是正常结果。长度 8、块大小 3 时，块长度依次为 3、3、2，调用方应按 len(chunk) 处理，而不是假设每块都有 3 个元素。

空输入：空切片对应的序列为空，不会额外 yield 一个长度为 0 的空块。因此下面的循环不会进入：

for chunk := range slices.Chunk([]int{}, 100) {
    // 空切片不会产生空 chunk，这里不会执行。
    fmt.Println(chunk)
}

n 小于 1：slices.Chunk(items, n) 要求 n 至少为 1，传入 0 或负数会 panic。配置项、请求参数或命令行参数来自外部时，优先在业务入口转换成明确错误。

旧版本 Go 的兼容实现

如果项目还不能使用 Go 1.23 的标准库，可以保留同样的“每块最多 n 个元素”契约，用索引计算尾部位置。这个版本返回的也是原切片视图，所以异步保存时同样需要复制。

func forEachChunk[T any](items []T, size int, fn func([]T) error) error {
    if size  len(items) {
            // 尾部不足一个完整块时，把终点收紧到切片长度。
            end = len(items)
        }
        if err := fn(items[start:end]); err != nil {
            return err
        }
    }
    return nil
}

与 slices.Chunk 相比，手写版本需要自己维护步长、尾部边界和参数检查；升级到 Go 1.23 后，优先使用标准库可以减少这部分重复代码。

落地清单：按这几项决定是否使用 Chunk

• 项目使用 Go 1.23 或更高版本，并且允许导入标准库 slices。
• 单批处理逻辑能接受最后一块短于固定大小。
• 只在当前调用链内消费分块；跨 goroutine 或长期保存前先 slices.Clone。
• 对来自外部的块大小先检查是否大于 0，不把配置错误留给 panic。
• 需要兼容旧版本时，保持手写实现与上述尾块、空输入语义一致。

常见问题

slices.Chunk 会返回 [][]T 吗？

不会。它返回的是 iter.Seq 迭代器，使用 range 时一次得到一个子切片；只有你主动收集，才会形成额外的容器。

最后一块一定和块大小相同吗？

不一定。除非输入长度刚好整除块大小，否则最后一块会保留剩余元素，长度小于块大小。

可以修改 chunk 中的元素吗？

可以，但它是原切片的视图，修改可能影响原切片。若要隔离所有权，请先复制后再修改或异步传递。