Go语言通过接口、闭包和泛型实现迭代器模式，1. 定义Iterator接口解耦遍历与数据结构；2. 结构体如SliceIterator实现HasNext/Next方法遍历切片；3. 闭包封装索引状态提供轻量级迭代；4. Go 1.18泛型支持类型安全的GenericIterator，避免类型断言，提升复用性与性能。
在 Go 语言中，虽然没有像 Java 或 C++ 那样内置的迭代器接口，但通过接口（interface）和闭包的组合，可以非常灵活地实现迭代器模式。这种模式适用于需要统一方式遍历不同数据结构集合的场景，比如切片、链表、树等。
什么是迭代器模式
迭代器模式提供一种方法顺序访问聚合对象中的各个元素，而又不暴露其内部表示。它将遍历逻辑与数据结构解耦，使代码更清晰、可复用。
在 Go 中，我们可以通过定义一个通用的 Iterator 接口来实现这一模式：
type Iterator interface {
HasNext() bool
Next() interface{}
}
基于切片的简单迭代器实现
以遍历一个字符串切片为例，我们可以构建一个具体的迭代器类型：
立即学习“go语言免费学习笔记（深入）”；
type SliceIterator struct {
items []string
index int
}
func NewSliceIterator(items []string) *SliceIterator {
return &SliceIterator{items: items, index: 0}
}
func (it *SliceIterator) HasNext() bool {
return it.index < len(it.items)
}
func (it *SliceIterator) Next() interface{} {
if !it.HasNext() {
return nil
}
item := it.items[it.index]
it.index++
return item
}
使用方式如下：
items := []string{"apple", "banana", "cherry"}
iter := NewSliceIterator(items)
for iter.HasNext() {
fmt.Println(iter.Next())
}
使用闭包实现轻量级迭代器
Go 的闭包特性允许我们创建更简洁的迭代器。这种方式适合简单的遍历需求，无需定义完整结构体。
func NewStringSliceIterator(items []string) func() (string, bool) {
index := 0
return func() (string, bool) {
if index >= len(items) {
return "", false
}
value := items[index]
index++
return value, true
}
}
调用示例：
next := NewStringSliceIterator([]string{"a", "b", "c"})
for {
val, ok := next()
if !ok {
break
}
fmt.Println(val)
}
这种函数式风格的迭代器更加紧凑，适合局部使用且不需要状态持久化的场景。
泛型迭代器（Go 1.18+）
从 Go 1.18 开始支持泛型，我们可以写出类型安全的通用迭代器：
type GenericIterator[T any] struct {
items []T
index int
}
func NewGenericIterator[T any](items []T) *GenericIterator[T] {
return &GenericIterator[T]{items: items, index: 0}
}
func (it *GenericIterator[T]) HasNext() bool {
return it.index < len(it.items)
}
func (it *GenericIterator[T]) Next() T {
if !it.HasNext() {
var zero T
return zero
}
item := it.items[it.index]
it.index++
return item
}
使用泛型版本：
iter := NewGenericIterator([]int{1, 2, 3})
for iter.HasNext() {
fmt.Println(iter.Next())
}
这避免了类型断言，提升了性能和安全性。
基本上就这些。Go 虽无原生迭代器语法，但凭借接口、闭包和泛型，完全可以实现高效、清晰的遍历逻辑。根据实际需求选择结构体封装还是闭包方式，能让代码更易维护。关键在于分离遍历行为与数据结构本身，提升抽象层次。
