在Golang项目开发中，我们经常会自定义各种集合类型来存储数据，比如自定义的切片封装集合、链表集合等。如果直接让外部代码通过索引或者访问内部字段的方式遍历集合，就会让外部代码和集合的内部结构强耦合，一旦后续需要调整集合的底层存储逻辑，所有依赖这些结构的遍历代码都需要修改，维护成本会非常高。迭代器模式就是专门解决这类问题的设计模式，它通过抽象出统一的遍历接口，让集合的使用者只需要关注遍历操作本身，不需要了解集合内部的实现细节。
迭代器模式的核心角色
迭代器模式主要包含两个核心角色，分别是迭代器接口和集合接口，两者配合实现遍历逻辑和内部结构的分离：
- 迭代器接口：定义遍历集合的统一方法，比如判断是否还有下一个元素、获取下一个元素等，所有具体的迭代器都需要实现这个接口。
- 集合接口：定义获取对应迭代器的方法，集合的具体实现类需要返回适配自身结构的迭代器实例。
Golang中迭代器模式的实现步骤
1. 定义迭代器接口
首先我们需要定义一个通用的迭代器接口，包含遍历所需的基础方法，这里以遍历字符串集合为例：
// Iterator 迭代器接口，定义遍历的统一方法
type Iterator interface {
// HasNext 判断是否还有下一个元素
HasNext() bool
// Next 获取下一个元素，如果没有元素返回空字符串和false
Next() (string, bool)
}
2. 定义集合接口
集合接口只需要提供一个返回迭代器的方法，不需要暴露内部的存储结构：
// Collection 集合接口，屏蔽内部结构，只暴露获取迭代器的方法
type Collection interface {
// GetIterator 返回当前集合对应的迭代器实例
GetIterator() Iterator
}
3. 实现具体的集合和对应迭代器
我们实现一个基于切片存储的字符串集合，内部使用私有的切片字段存储数据，外部无法直接访问，只能通过迭代器遍历：
// StringSliceCollection 基于切片实现的字符串集合，内部结构私有
type StringSliceCollection struct {
// data 内部存储切片，首字母小写，外部无法直接访问
data []string
}
// NewStringSliceCollection 创建字符串集合的构造函数
func NewStringSliceCollection(items []string) *StringSliceCollection {
return &StringSliceCollection{
data: items,
}
}
// GetIterator 实现Collection接口的GetIterator方法，返回适配切片的迭代器
func (c *StringSliceCollection) GetIterator() Iterator {
return &stringSliceIterator{
collection: c,
index: 0,
}
}
// stringSliceIterator 切片集合对应的迭代器，私有结构体，外部无法直接创建
type stringSliceIterator struct {
collection *StringSliceCollection
index int
}
// HasNext 实现Iterator接口的HasNext方法
func (it *stringSliceIterator) HasNext() bool {
return it.index < len(it.collection.data)
}
// Next 实现Iterator接口的Next方法
func (it *stringSliceIterator) Next() (string, bool) {
if !it.HasNext() {
return "", false
}
item := it.collection.data[it.index]
it.index++
return item, true
}
4. 使用迭代器遍历集合
外部代码只需要依赖集合接口和迭代器接口，不需要知道集合内部是切片还是其他结构，就能完成遍历：
package main
import "fmt"
func main() {
// 创建集合实例，传入初始数据
collection := NewStringSliceCollection([]string{"apple", "banana", "cherry"})
// 获取迭代器
iterator := collection.GetIterator()
// 遍历集合元素
for iterator.HasNext() {
item, ok := iterator.Next()
if ok {
fmt.Println(item)
}
}
}
屏蔽内部结构细节的优势
通过上述实现可以看到，StringSliceCollection的内部data字段是私有的，外部代码无法直接访问，只能通过GetIterator方法获取迭代器来遍历。如果后续我们需要把集合的底层存储从切片改成链表，只需要修改StringSliceCollection的内部结构和对应的stringSliceIterator实现，外部使用集合和迭代器的代码完全不需要修改，大大降低了代码的耦合度。
通用迭代器的扩展思路
如果我们需要支持不同类型的集合，比如整数集合、自定义结构体集合，可以使用Golang的泛型来定义通用的迭代器和集合接口，避免重复编写相似的代码：
// GenericIterator 泛型迭代器接口
type GenericIterator[T any] interface {
HasNext() bool
Next() (T, bool)
}
// GenericCollection 泛型集合接口
type GenericCollection[T any] interface {
GetIterator() GenericIterator[T]
}
// GenericSliceCollection 泛型切片集合实现
type GenericSliceCollection[T any] struct {
data []T
}
// NewGenericSliceCollection 创建泛型集合
func NewGenericSliceCollection[T any](items []T) *GenericSliceCollection[T] {
return &GenericSliceCollection[T]{
data: items,
}
}
// GetIterator 返回泛型迭代器
func (c *GenericSliceCollection[T]) GetIterator() GenericIterator[T] {
return &genericSliceIterator[T]{
collection: c,
index: 0,
}
}
// genericSliceIterator 泛型迭代器实现
type genericSliceIterator[T any] struct {
collection *GenericSliceCollection[T]
index int
}
func (it *genericSliceIterator[T]) HasNext() bool {
return it.index < len(it.collection.data)
}
func (it *genericSliceIterator[T]) Next() (T, bool) {
if !it.HasNext() {
var zero T
return zero, false
}
item := it.collection.data[it.index]
it.index++
return item, true
}
使用泛型迭代器后，我们可以复用同一套逻辑处理不同类型的集合，同时依然保持内部结构的屏蔽，外部代码不需要关心集合的底层存储和元素类型的具体实现细节。