如何使用Golang实现迭代器模式_Golang迭代器模式集合遍历方法

Go没有原生迭代器接口，因其哲学强调显式优于隐式、简单优于抽象；range已满足多数遍历需求，而函数值、接口和泛型三种方式可按场景选择实现轻量、可组合或类型安全的迭代器。

为什么 Go 语言没有原生迭代器接口

Go 不像 Java 或 C# 那样内置 Iterator 接口或 for...of 语法糖，核心原因是 Go 哲学强调显式优于隐式、简单优于抽象。标准库中 range 已覆盖绝大多数集合遍历需求，强行套用传统迭代器模式反而增加冗余类型和内存分配。

但当你需要：延迟计算（如读取大文件行）、状态保持（如树的中序遍历）、封装内部结构（如跳表、B+ 树）、或统一多数据源访问（DB cursor + slice + channel）时，手写迭代器就变得必要。

用函数值实现轻量级迭代器（最常用）

Go 中最自然、零开销的方式是返回一个闭包函数，每次调用返回下一个元素和是否结束的标志。它避免了接口定义、结构体字段和指针解引用开销。

• func() (T, bool) 是事实上的“迭代器类型”，被 database/sql.Rows.Next()、bufio.Scanner.Scan() 等广泛采用
• 不暴露内部状态，调用方无法重置或跳转，符合“单向消费”语义
• 注意闭包捕获的变量生命周期：若迭代器需长期存活，确保其引用的数据不会提前被 GC

func IntSliceIter(nums []int) func() (int, bool) {
    i := 0
    return func() (int, bool) {
        if i >= len(nums) {
            return 0, false
        }
        val := nums[i]
        i++
        return val, true
    }
}
// 使用
next := IntSliceIter([]int{1, 2, 3})
for {
if val, ok := next(); ok {
fmt.Println(val)
} else {
break
}
}

用接口定义可组合的迭代器（适合复杂场景）

当需要链式操作（如 Filter、Map、Take）或多态统一处理时，定义接口更清晰。但要注意：接口值包含动态分发开销，且每次调用都涉及一次间接跳转。

• 推荐只在真正需要运行时多态时才用接口；否则优先用函数值或泛型函数
• 不要把 Next() 设计成返回 error —— 迭代结束是正常控制流，用 bool 更符合 Go 惯例
• 避免在 Next() 中做昂贵操作（如网络请求），否则无法预测性能

type Iterator[T any] interface {
    Next() (T, bool)
}
func Filter[T any](it Iterator[T], f func(T) bool) Iterator[T] {
return &filterIter[T]{it: it, f: f}
}
type filterIter[T any] struct {
it Iterator[T]
f  func(T) bool
cur T
ok  bool
}
func (f *filterIter[T]) Next() (T, bool) {
for {
if val, ok := f.it.Next(); ok {
if f.f(val) {
return val, true
}
} else {
return f.cur, false
}
}
}

泛型 + 迭代器工厂函数（Go 1.18+ 推荐方式）

Go 泛型让迭代器能复用逻辑又保持类型安全。比起为每种类型写一遍函数，用泛型一次定义，编译期生成特化版本，既无接口开销，又避免重复代码。

• 工厂函数名建议带 Iter 后缀（如 MapIter），与标准库 strings.Map 等命名一致
• 避免在泛型函数里直接返回具体结构体指针（如 &mapIter{...}），而应返回接口或函数值，否则用户可能误用未导出字段
• 如果迭代逻辑依赖外部状态（如 mutex、context），记得在工厂函数参数中显式传入

func MapIter[T, U any](it func() (T, bool), f func(T) U) func() (U, bool) {
    return func() (U, bool) {
        if val, ok := it(); ok {
            return f(val), true
        }
        var zero U
        return zero, false
    }
}
// 使用
nums := []int{1, 2, 3}
iter := MapIter(IntSliceIter(nums), func(x int) string { return fmt.Sprintf("v%d", x) })
for {
if s, ok := iter(); ok {
fmt.Println(s) // "v1", "v2", "v3"
} else {
break
}
}

真正难的不是写出一个能跑的迭代器，而是判断该不该用、用哪种形式。函数值适用于 90% 的场景；接口适合需要动态组合或统一调度的地方；泛型则是在两者之间找平衡——它要求你对类型关系有足够清晰的建模，否则容易陷入过度设计。