Go iter.Seq2 返回键值时怎么避免复制大对象

如果 iter.Seq2[K, V] 的 V 是一个很大的结构体，直接写 for key, value := range seq 并不会自动变成“按引用遍历”。Seq2 的定义是把键和值作为参数传给 yield，而值参数本身仍然遵守 Go 的值语义。要减少大对象搬运，优先把序列改成 iter.Seq2[K, *V]，或者只返回 ID、索引等紧凑句柄；不要指望在循环里写 &value 来挽回已经发生的复制。

结论很简单：大对象需要完整访问时返回指针，需要稳定边界时返回 ID/索引，需要独立快照时才保留值返回。先决定所有权，再决定 Seq2 的类型。

看清 Seq2 的值传递边界

iter.Seq2 适合表达键值对序列，常见形状如下：

type Seq2[K, V any] func(yield func(K, V) bool)

type Record struct {
    ID      int64
    Payload [1024]byte
}

func (s *Store) All() iter.Seq2[int64, Record] {
    return func(yield func(int64, Record) bool) {
        for _, record := range s.records {
            // yield 接收的是 Record 值，不是记录存储位置。
            if !yield(record.ID, record) {
                return
            }
        }
    }
}

在这个签名里，Record 会以值的形式进入 yield，再成为 range 变量 value。编译器可能优化具体的物理搬运，但 API 语义并没有因此变成引用。尤其不要把下面的写法当成优化：

for _, value := range store.All() {
    // 这里拿到的是当前值副本的地址，不是底层切片元素的地址。
    consume(&value)
}

让 Seq2 返回指针或紧凑句柄

如果调用方确实要读取完整记录，直接把元素类型改成指针更诚实。生产端按索引取元素地址，避免先复制一个大结构体：

func (s *Store) AllPointers() iter.Seq2[int64, *Record] {
    return func(yield func(int64, *Record) bool) {
        for i := range s.records {
            record := &s.records[i]
            // 返回存储中的地址，调用方不再接收整个 Record 值。
            if !yield(record.ID, record) {
                return
            }
        }
    }
}

for id, record := range store.AllPointers() {
    // id 用于日志或索引，record 用于读取完整字段。
    if record.ID == id {
        consume(record)
    }
}

指针方案不是免费优化：它暴露了别名关系。底层切片扩容、记录被复用、调用方并发修改时，指针的有效期和读写同步都要有约定。若不想暴露内部对象，可返回 uint32 或业务 ID：

func (s *Store) IDs() iter.Seq2[int64, uint32] {
    return func(yield func(int64, uint32) bool) {
        for i := range s.records {
            // 只传递小句柄，完整对象仍由 Store 管理。
            if !yield(s.records[i].ID, uint32(i)) {
                return
            }
        }
    }
}

for id, index := range store.IDs() {
    record, ok := store.Lookup(index)
    // 句柄可能失效，所以读取入口必须返回有效性。
    if ok && record.ID == id {
        consume(record)
    }
}

检查生命周期、别名和可变性

可以用下面的表快速选型。重点不是“指针一定更快”，而是让返回类型准确表达谁拥有数据。

如果底层数据会变化，可以在迭代开始前建立稳定快照，或让 Store 在迭代期间持有读锁；不要返回一个可能随着切片扩容而失效的地址。若调用方只读，文档中也要明确“指针不可修改”是约定，而不是 Go 类型系统提供的只读保证。

组合迭代器并可靠提前停止

Seq2 的惰性特点仍然保留：消费者返回 false 时，生产端必须立即停止继续 yield。需要把推式迭代器转换为拉式迭代器时，记得在没有读完的分支调用 stop：

func FirstMatch(seq iter.Seq2[int64, *Record], want int64) *Record {
    next, stop := iter.Pull2(seq)
    defer stop() // 提前返回时释放拉式迭代器的剩余状态。

    for {
        id, record, ok := next()
        if !ok {
            return nil
        }
        // 只保留匹配记录，其他值不复制完整结构体。
        if id == want {
            return record
        }
    }
}

最终检查三件事：V 是否真的需要完整值、指针是否越过了存储生命周期、句柄是否有明确的失败路径。把这三点写进 API 注释，比单纯追求一个“零复制”口号更可靠。

常见问题

Seq2 的键也会复制吗？

会按 K 的值语义传递。通常键是整数、字符串或小结构体，成本较低；如果键也很大，应重新设计为小键或句柄。

把切片改成存指针就一定更好吗？

不一定。指针减少大结构体值搬运，却增加了间接访问和生命周期管理；对象很小、需要快照或并发隔离时，保留值返回更清楚。

为什么 range 里取地址后仍可能看到旧数据？

因为地址指向的是本轮接收的变量，不是原始存储。要拿到底层元素地址，必须在生产端按索引取地址，并明确它的有效期和并发规则。