Go语言通过接口和闭包实现迭代器模式，以Next()和Value()方法或返回函数的形式遍历集合，解耦算法与数据结构，支持Map、Filter、Reduce等操作，提升代码可读性与复用性。
在Go语言中，虽然没有像其他面向对象语言那样直接支持“迭代器模式”的语法结构，但通过接口和闭包的组合，可以非常自然地实现类似行为。特别是在处理集合遍历与操作时，使用迭代器模式能提升代码的可读性、复用性和扩展性。
什么是迭代器模式
迭代器模式提供一种方式顺序访问集合中的元素，而不暴露其内部结构。它将遍历逻辑从数据结构中解耦，使得算法与容器独立变化。
在Go中，我们通常通过以下方式模拟迭代器：
- 定义一个包含 Next() 和 Value() 方法的接口
- 为具体集合类型实现该接口
- 利用闭包封装状态，返回函数形式的迭代器
基于接口的迭代器实现
以一个简单的整数切片为例，构建一个可重用的迭代器：
立即学习“go语言免费学习笔记（深入）”；
type Iterator interface {
Next() bool
Value() int
}
type IntSliceIterator struct {
slice []int
index int
}
func (it *IntSliceIterator) Next() bool {
if it.index < len(it.slice) {
return true
}
return false
}
func (it *IntSliceIterator) Value() int {
defer func() { it.index++ }()
return it.slice[it.index]
}
使用方式如下：
slice := []int{1, 2, 3}
iter := &IntSliceIterator{slice: slice}
for iter.Next() {
fmt.Println(iter.Value()) // 输出 1, 2, 3
}
这种方式适合需要多次遍历或复杂控制流程的场景。
函数式迭代器：闭包的简洁用法
Go的闭包非常适合实现轻量级迭代器。返回一个函数，每次调用返回下一个值：
func NewIntSliceIterator(slice []int) func() (int, bool) {
index := 0
return func() (int, bool) {
if index >= len(slice) {
return 0, false
}
v := slice[index]
index++
return v, true
}
}
使用示例：
next := NewIntSliceIterator([]int{10, 20, 30})
for {
v, ok := next()
if !ok {
break
}
fmt.Println(v)
}
这种风格更符合Go的习惯写法，代码简洁，适用于一次性遍历。
组合操作：Map、Filter、Reduce 的模拟
借助迭代器，可以实现类似函数式编程的操作链：
- Map：对每个元素应用函数
- Filter：跳过不满足条件的元素
- Reduce：聚合所有元素为单一值
例如实现一个过滤迭代器：
func Filter(iter func() (int, bool), pred func(int) bool) func() (int, bool) {
return func() (int, bool) {
for {
v, ok := iter()
if !ok {
return 0, false
}
if pred(v) {
return v, true
}
}
}
}
然后这样使用：
next := NewIntSliceIterator([]int{1, 2, 3, 4, 5})
even := Filter(next, func(x int) bool { return x % 2 == 0 })
for v, ok := even(); ok; v, ok = even() {
fmt.Println(v) // 输出 2, 4
}
基本上就这些。Go虽无原生迭代器语法，但通过接口或闭包，完全可以实现灵活高效的集合遍历机制。关键是根据使用场景选择合适的形式：需要状态管理用结构体+接口，追求简洁用闭包。迭代器模式让集合操作更清晰可控。
