如何使用Golang实现迭代器集合遍历_使用Iterator Pattern访问集合_技术教程

Go 语言虽无内置 Iterator 接口，但可通过闭包（返回 (value, bool) 函数）、泛型接口（Iterator[T]）或 channel 实现安全、解耦、可组合的迭代器模式，适配 slice、链表、IO 等多种场景。

Go 语言本身没有内置的 Iterator 接口（不像 Java 或 C#），但你可以通过函数式风格或接口抽象，清晰、安全地实现类似迭代器模式（Iterator Pattern）的集合遍历。核心思路是：**将“如何访问集合内部元素”的逻辑封装起来，与集合结构解耦，同时支持多种遍历方式（如正向、反向、过滤、懒求值等）**。

用闭包模拟迭代器（最轻量实用）

对简单场景（如 slice、map），直接返回一个无参数、返回 (value, bool) 的函数，是最符合 Go 习惯的做法：

func NewIntSliceIterator(slice []int) func() (int, bool) {
    i := -1
    return func() (int, bool) {
        i++
        if i >= len(slice) {
            return 0, false
        }
        return slice[i], true
    }
}

使用时：

iter := NewIntSliceIterator([]int{10, 20, 30})
for v, ok := iter(); ok; v, ok = iter() {
    fmt.Println(v) // 输出 10, 20, 30
}

无需定义额外类型或接口，零内存分配（闭包捕获局部变量）
天然支持“一次遍历”，避免重复调用导致状态混乱
可轻松组合：比如写个 FilterIterator 包裹原始迭代器，只返回满足条件的元素

用接口定义标准 Iterator（适合复杂集合）

当你的集合类型较复杂（如树、图、链表、数据库游标），建议定义显式接口，提升可测试性和扩展性：

type Iterator[T any] interface {
    Next() bool          // 移动到下一个元素，返回是否成功
    Value() T            // 获取当前元素值（要求 Next() 返回 true 后才调用）
    Err() error          // 可选：支持带错误的迭代（如 I/O 迭代器）
}

示例：为自定义链表实现迭代器

type ListNode[T any] struct {
    Val  T
    Next *ListNode[T]
}
type ListIterator[T any] struct {
curr *ListNode[T]
}
func (it *ListIterator[T]) Next() bool {
if it.curr == nil {
return false
}
it.curr = it.curr.Next
return it.curr != nil
}
func (it *ListIterator[T]) Value() T {
return it.curr.Val
}
func (l *LinkedList[T]) Iterator() Iterator[T] {
return &ListIterator[T]{curr: &ListNode[T]{Next: l.head}} // 哨兵节点简化逻辑
}

调用方只依赖 Iterator[T] 接口，完全不感知底层是链表还是跳表
支持多路并发遍历（每个 Iterator 实例维护独立状态）
可嵌套：比如 MapIterator 封装另一个 Iterator 并转换元素类型

结合 channel 实现并发/流式迭代（处理大数据或 IO）

当遍历涉及网络请求、文件读取或需要 goroutine 协作时，用 channel 是更自然的选择：

func IterateLines(filename string) <-chan string {
    ch := make(chan string)
    go func() {
        defer close(ch)
        file, _ := os.Open(filename)
        defer file.Close()
        scanner := bufio.NewScanner(file)
        for scanner.Scan() {
            ch <- scanner.Text()
        }
    }()
    return ch
}

使用：

for line := range IterateLines("log.txt") {
    process(line)
}

天然支持异步生产 + 同步消费，避免阻塞主流程
配合 context.Context 可轻松实现超时、取消（在 goroutine 内监听 ctx.Done()）
注意：channel 迭代器不适合“回退”或“多次遍历”，属于一次性流

避免常见陷阱

不要暴露集合内部结构 —— 别让调用方直接操作 slice 的 index 或 map 的 keys；迭代器应是唯一访问入口。
区分 “有无元素” 和 “遍历结束” —— 比如 map 迭代中 value 可能是零值，所以必须用 ok 或 Next() 返回布尔值判断，而非仅检查 Value() != zero。
资源清理要明确 —— 若迭代器打开文件、数据库连接等，提供 Close() 方法并文档注明需手动调用（或用 defer 包裹）。

基本上就这些。Go 的迭代器不必追求“严格符合 GoF 模式”，而应优先简洁、安全、符合惯用法：小集合用闭包，复杂结构用接口，IO/并发场景用 channel。