如何在Golang中实现迭代器模式_Golang迭代器模式集合遍历方法_技术教程

Go 中可通过闭包返回无参函数实现轻量迭代器，或定义 Next/Value 接口支持多集合统一遍历，亦可用 channel 实现协程安全的异步迭代。

在 Go 语言中没有内置的迭代器接口（如 Java 的 Iterator 或 Python 的 __iter__），但可以通过函数式风格、闭包和接口组合，自然、高效地实现迭代器模式，用于集合遍历。

用闭包封装状态，返回迭代函数

最轻量、Go 风格的做法是返回一个无参函数，每次调用返回下一个元素和是否结束的标志：

适合一次性遍历，无需维护复杂状态
避免定义额外结构体和方法，代码简洁直观
底层数据可被安全封装，外部无法直接修改

示例：遍历切片的迭代器

func NewSliceIterator[T any](s []T) func() (T, bool) {
    i := 0
    return func() (T, bool) {
        if i >= len(s) {
            var zero T
            return zero, false
        }
        val := s[i]
        i++
        return val, true
    }
}
// 使用
it := NewSliceIterator([]string{"a", "b", "c"})
for {
v, ok := it()
if !ok {
break
}
fmt.Println(v)
}

定义 Iterator 接口，支持多种集合统一遍历

当需要适配不同数据结构（如链表、树、映射）时，可定义标准接口，提升扩展性与测试友好性：

推荐使用 Next() bool + Value() T 分离设计，更符合 Go 的错误处理习惯
避免在 Value() 中隐式 panic 或返回零值误导调用方
配合 HasNext() 可提前判断，适合需预读的场景

示例接口及切片实现

type Iterator[T any] interface {
    Next() bool      // 移动到下一元素，返回是否成功
    Value() T        // 获取当前元素（仅在 Next() 返回 true 后有效）
}
type SliceIterator[T any] struct {
slice []T
index int
}
func (it *SliceIterator[T]) Next() bool {
if it.index < len(it.slice)-1 {
it.index++
return true
}
return false
}
func (it *SliceIterator[T]) Value() T {
if it.index < len(it.slice) {
return it.slice[it.index]
}
var zero T
return zero
}
// 使用
it := &SliceIterator[string]{slice: []string{"x", "y", "z"}}
for it.Next() {
fmt.Println(it.Value())
}

结合 for-range 和 channel 实现协程迭代器

对耗时操作（如文件行读取、数据库游标、网络流）或需异步生成数据的场景，channel 是更自然的选择：

生产者-消费者解耦，天然支持并发生成
可配合 context 控制生命周期，支持取消
调用侧用 for range ch，语义清晰，自动关闭处理

示例：从切片生成通道迭代器

func SliceChannelIterator[T any](s []T) <-chan T {
    ch := make(chan T)
    go func() {
        defer close(ch)
        for _, v := range s {
            ch <- v
        }
    }()
    return ch
}
// 使用
for v := range SliceChannelIterator([]int{10, 20, 30}) {
fmt.Println(v)
}