Go中实现迭代器模式有四种方式：1. 定义Iterator接口规范Next、Value方法；2. 封装集合与迭代器，如IntSlice提供Iterator方法；3. 用闭包模拟惰性迭代，返回函数维持状态；4. 利用channel配合goroutine实现并发安全遍历。
在Golang中实现迭代器模式，可以有效解耦数据结构与遍历逻辑，提升代码的可维护性和扩展性。由于Go语言本身没有像Java或C++那样的内置接口支持（如Iterator接口），因此需要手动定义迭代器行为。下面介绍几种常见的实现方式。
1. 基于接口的通用迭代器设计
通过定义一个统一的Iterator接口，规范遍历操作的基本方法，如Next()、Value()和HasNext()。
示例：
type Iterator interface {
Next() bool
Value() interface{}
}
type SliceIterator struct {
slice []interface{}
index int
}
func (it *SliceIterator) Next() bool {
it.index++
return it.index < len(it.slice)
}
func (it *SliceIterator) Value() interface{} {
if it.index >= 0 && it.index < len(it.slice) {
return it.slice[it.index]
}
return nil
}
使用时只需调用Next判断是否还有元素，再通过Value获取当前值。
立即学习“go语言免费学习笔记（深入）”；
2. 结合结构体封装集合与迭代器
将数据集合和其对应的迭代器绑定在一起，提供更清晰的访问方式。例如为自定义链表、树或数组封装专属迭代器。
以切片为例：
type IntSlice struct {
data []int
}
func (s IntSlice) Iterator() IntSliceIterator {
return &IntSliceIterator{data: s.data, index: -1}
}
type IntSliceIterator struct {
data []int
index int
}
func (it *IntSliceIterator) Next() bool {
it.index++
return it.index < len(it.data)
}
func (it *IntSliceIterator) Value() int {
return it.data[it.index]
}
这样外部无需关心内部结构，仅通过Iterator方法获取遍历能力。
3. 使用闭包模拟惰性迭代
Go支持闭包，可以用函数返回一个状态保持的遍历函数，实现类似生成器的效果。
示例：创建一个能逐个返回整数的迭代器
func IntRange(from, to int) func() (int, bool) {
i := from - 1
return func() (int, bool) {
i++
return i, i <= to
}
}
使用方式：
next := IntRange(1, 3)
for val, ok := next(); ok; val, ok = next() {
fmt.Println(val)
}
这种方式简洁，适合简单场景或流式处理。
4. 利用channel实现并发安全迭代
对于需要并发访问或异步处理的集合，可通过goroutine配合channel实现非阻塞迭代。
func IterateAsync(data []int) <-chan int {
ch := make(chan int)
go func() {
for _, v := range data {
ch <- v
}
close(ch)
}()
return ch
}
遍历时直接range channel即可：
for v := range IterateAsync([]int{1, 2, 3}) {
fmt.Println(v)
}
这种模式适用于大数据量或IO密集型任务中的逐步消费。
基本上就这些常用方式。选择哪种取决于具体需求：接口方式灵活通用，闭包轻量便捷，channel适合并发，而结构体封装利于复杂数据结构管理。合理运用能让遍历逻辑更清晰、复用性更强。不复杂但容易忽略的是边界控制和索引初始化位置（比如index设为-1）。
