如何手动迭代Go语言中的Iterator？

问题背景 #

Go即将推出的iter包中定义了两种便捷的迭代器类型：

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

目前标准用法是通过for range进行迭代：

// All 返回一个Seq迭代器
for v := range myType.All() {
    // 处理元素v
}

但实际场景中，有时需要从迭代器外部控制迭代（比如随时停止迭代），希望能直接通过Next()方法逐个获取元素：

iterator := myType.All()
v, ok := iterator.Next()

原生Seq类型的限制 #

原生的Seq和Seq2本质是函数类型，本身并没有Next()方法，因此无法直接通过上述方式调用。这类迭代器是为for range语法设计的，迭代过程由Go运行时控制，外部无法直接干预。

实现Next()式迭代的方案 #

如果需要支持Next()调用，可以自行封装一个带状态的迭代器结构体，将Seq转换为可手动控制的迭代器。以下是几种常见实现方式：

1. 基于通道的封装（简单易实现） #

利用通道将Seq的元素逐个传递，通过通道接收实现Next()：

import "sync"

type Iterator[V any] struct {
    nextFn func() (V, bool)
}

func NewIterator[V any](seq Seq[V]) *Iterator[V] {
    var (
        ch   chan V
        once sync.Once
    )

    return &Iterator[V]{
        nextFn: func() (V, bool) {
            once.Do(func() {
                ch = make(chan V, 1)
                go func() {
                    // 遍历Seq并将元素发送到通道
                    seq(func(v V) bool {
                        ch <- v
                        return true
                    })
                    close(ch)
                }()
            })

            v, ok := <-ch
            return v, ok
        },
    }
}

// Next 获取下一个元素，返回元素和是否还有下一个的标志
func (it *Iterator[V]) Next() (V, bool) {
    return it.nextFn()
}

使用方式：

iterator := NewIterator(myType.All())
for {
    v, ok := iterator.Next()
    if !ok {
        break
    }
    // 处理元素v
    // 可随时break终止迭代
}

2. 基于闭包状态的封装（无goroutine开销） #

如果对性能敏感，可以通过闭包保存迭代状态，避免goroutine和通道的开销：

type Iterator[V any] struct {
    next func() (V, bool)
}

func NewIterator[V any](seq Seq[V]) *Iterator[V] {
    var (
        current V
        hasNext bool
        // 0:未启动 1:已获取元素待返回 2:迭代结束
        state int
        yield func(V) bool
    )

    yield = func(v V) bool {
        current = v
        hasNext = true
        state = 1
        return false // 每次仅获取一个元素就暂停迭代
    }

    return &Iterator[V]{
        next: func() (V, bool) {
            switch state {
            case 0:
                // 首次调用，启动迭代
                hasNext = false
                seq(yield)
            case 1:
                // 继续上次暂停的迭代
                hasNext = false
                seq(yield)
            }

            if hasNext {
                return current, true
            }
            state = 2
            var zero V
            return zero, false
        },
    }
}

func (it *Iterator[V]) Next() (V, bool) {
    return it.next()
}

这种方式通过控制yield函数的返回值，实现迭代的暂停和继续，完全在当前goroutine中执行，性能更高。

总结 #

原生iter包的Seq迭代器不支持直接调用Next()，但可以通过自行封装结构体的方式实现该功能，满足外部控制迭代的需求。不同封装方式各有优劣，可根据场景选择：

• 通道实现简单易维护，适合大多数场景；
• 闭包状态实现性能更高，适合性能敏感的场景。

内容的提问来源于stack exchange，提问作者ilya_dt