在Golang开发中，当我们需要封装自定义的集合类型时，直接暴露集合的内部存储结构会让外部代码与集合实现产生强耦合，后续修改集合内部逻辑时会影响所有使用集合的代码。迭代器模式可以将集合的遍历逻辑从集合本身剥离，通过统一的接口提供遍历能力，既保护了集合的内部结构，也让遍历逻辑可以灵活扩展。
迭代器模式的核心角色
迭代器模式主要包含三个核心角色，在Golang中可以通过接口和结构体来实现：
- 集合接口：定义获取迭代器的方法，所有自定义集合都需要实现这个接口
- 迭代器接口：定义遍历集合需要的核心方法，比如判断是否还有下一个元素、获取下一个元素
- 具体集合与具体迭代器：具体集合实现集合接口，返回对应的具体迭代器；具体迭代器实现迭代器接口，维护遍历的当前位置，实现具体的遍历逻辑
定义迭代器相关接口
首先我们定义迭代器接口和自定义集合的接口，迭代器接口需要包含遍历的基础方法：
// 迭代器接口，定义遍历集合的基础方法
type Iterator interface {
// HasNext 判断是否还有下一个元素
HasNext() bool
// Next 获取下一个元素，如果没有元素返回nil
Next() interface{}
}
// 自定义集合接口，定义获取迭代器的方法
type Collection interface {
// GetIterator 返回当前集合对应的迭代器
GetIterator() Iterator
}
实现自定义集合与对应迭代器
我们实现一个简单的字符串集合作为自定义集合的示例，内部使用切片存储字符串元素，然后实现对应的迭代器：
// StringCollection 自定义字符串集合，实现Collection接口
type StringCollection struct {
data []string
}
// NewStringCollection 创建字符串集合的构造函数
func NewStringCollection(items []string) *StringCollection {
return &StringCollection{
data: items,
}
}
// GetIterator 实现Collection接口的GetIterator方法，返回对应的迭代器
func (c *StringCollection) GetIterator() Iterator {
return &StringIterator{
collection: c,
index: 0,
}
}
// StringIterator 字符串集合对应的迭代器，实现Iterator接口
type StringIterator struct {
collection *StringCollection
index int
}
// HasNext 实现Iterator接口的HasNext方法
func (it *StringIterator) HasNext() bool {
return it.index < len(it.collection.data)
}
// Next 实现Iterator接口的Next方法
func (it *StringIterator) Next() interface{} {
if !it.HasNext() {
return nil
}
item := it.collection.data[it.index]
it.index++
return item
}
使用迭代器遍历自定义集合
完成接口和实现后，我们可以通过迭代器来遍历自定义集合，不需要直接访问集合内部的切片结构：
func main() {
// 初始化自定义集合
collection := NewStringCollection([]string{"golang", "iterator", "pattern", "test"})
// 获取集合的迭代器
iterator := collection.GetIterator()
// 使用迭代器遍历集合
for iterator.HasNext() {
item := iterator.Next()
// 类型断言获取字符串值
if str, ok := item.(string); ok {
fmt.Println(str)
}
}
}
扩展迭代器功能
迭代器模式的好处是可以灵活扩展遍历逻辑，比如我们可以实现一个过滤迭代器，只返回长度大于5的字符串元素：
// FilterIterator 带过滤功能的迭代器
type FilterIterator struct {
iterator Iterator
// 过滤函数，返回true表示保留该元素
filterFunc func(interface{}) bool
}
// NewFilterIterator 创建过滤迭代器
func NewFilterIterator(it Iterator, filter func(interface{}) bool) *FilterIterator {
return &FilterIterator{
iterator: it,
filterFunc: filter,
}
}
// HasNext 重写HasNext方法，跳过不符合过滤条件的元素
func (f *FilterIterator) HasNext() bool {
for f.iterator.HasNext() {
nextItem := f.iterator.Next()
if f.filterFunc(nextItem) {
// 因为提前取了元素，需要暂存，这里简单处理为重新构造迭代器，实际场景可以用栈暂存
// 此处为简化示例，实际实现可以维护一个预取的元素缓存
return true
}
}
return false
}
// Next 获取下一个符合过滤条件的元素
func (f *FilterIterator) Next() interface{} {
// 简化实现，实际场景需要结合HasNext的预取逻辑返回元素
// 此处仅做示例展示扩展思路
return nil
}
通过上面的实现可以看到，使用迭代器模式后，自定义集合的遍历逻辑和存储逻辑完全分离，后续如果需要修改集合的存储结构，或者新增遍历方式，都不会影响已有的使用代码，大大提升了代码的可维护性和扩展性。