Go 语言中真的需要迭代器吗？

在日常开发中，我们经常需要遍历各种数据集合。Go语言提供了强大的for range循环来遍历切片、map等内置类型，那么对于自定义数据结构，我们是否真的需要迭代器呢？特别是随着Go 1.23版本迭代器的正式引入，这个问题值得重新思考。

内置遍历足够

Go语言内置了对常见数据结构的遍历支持，这是最直接和高效的方式：

// 遍历切片和map的简单示例
for index, value := range slice {
    // 处理每个元素
}

for key, value := range myMap {
    // 处理键值对
}

对于简单的内置类型，for range已经完全够用，而且性能最优。那么为什么还需要迭代器呢？

为什么需要迭代器？

1. 自定义数据结构的遍历

当你需要遍历二叉树、图、链表等自定义数据结构时，迭代器模式就显示出其价值了。迭代器可以隐藏内部的遍历逻辑，使用者无需了解二叉树的复杂结构即可进行遍历。

想象一下，如果每次遍历二叉树都需要重新写一遍复杂的中序/前序遍历算法，代码会变得多么冗余和容易出错！

2. 惰性求值和无限序列

迭代器支持按需生成数据，这在处理大量数据或无限序列时特别有用。比如斐波那契数列生成器：传统的做法需要预先计算并存储所有值，而迭代器可以按需生成每个数值，节省内存并提高效率。

3. 统一遍历接口

通过定义统一的迭代器接口，我们可以为不同的数据结构提供一致的遍历方式。无论是切片、map、二叉树还是数据库查询结果，都可以通过相同的访问方式。这种抽象使得代码更加灵活和可维护。

Go 1.23之前的迭代器实现方式

在Go 1.23之前，官方没有提供标准的迭代器支持，开发者需要自己实现。常见的方式有：

闭包方式（最常用）

func createIterator(slice []int) func() (int, bool) {
    index := 0
    return func() (int, bool) {
        // 返回下一个元素和是否继续的标志
    }
}

面向对象方式（类似Java）

type Iterator interface {
    HasNext() bool
    Next() interface{}
}

这些自定义实现虽然能用，但不够统一和简洁。

Go 1.23的革命：iter包

Go 1.23正式引入了iter包，提供了官方的迭代器标准。这是Go语言在迭代器方面的重大进步。

核心概念

Go 1.23迭代器的核心是两种类型：

• Seq[V any]：单值序列迭代器
• Seq2[K, V any]：键值对迭代器

推送式迭代器（Push Iterator）

这是Go的主要迭代器形式，迭代器主动将元素"推送"给回调函数。

import "iter"

func countTo(n int) iter.Seq[int] {
    returnfunc(yield func(int) bool) {
        for i := 1; i <= n; i++ {
            if !yield(i) {
                return
            }
        }
    }
}

// 使用
for n := range countTo(5) {
    fmt.Println(n) // 输出 1, 2, 3, 4, 5
}

这种方式的性能接近原生for循环，同时提供了更好的抽象能力。

拉取式迭代器（Pull Iterator）

与推送式相反，由使用者主动"拉取"值。

next, stop := iter.Pull(countTo(3))
defer stop()

for {
    n, ok := next()
    if !ok {
        break
    }
    fmt.Println(n)
}

拉取式迭代器比推送式性能慢两个数量级，仅用于特殊场景。

标准库的迭代器支持

Go 1.23的slices和maps包提供了丰富的迭代器工具函数：

slices包常用函数

• slices.All(s)：返回切片的键值对迭代器
• slices.Values(s)：返回切片的元素迭代器
• slices.Collect(seq)：将迭代器收集为切片

maps包常用函数

• maps.All(m)：返回map的键值对迭代器
• maps.Keys(m)：返回map的键迭代器
• maps.Values(m)：返回map的值迭代器

性能考量

在选择是否使用迭代器时，性能是一个重要考量因素，据网络资料显示：

• 原生for循环：性能最好，约2400 ns/op
• 推送式迭代器：约3700 ns/op，比原生慢约50%
• 拉取式迭代器：约570000 ns/op，比原生慢两个数量级

建议：性能敏感场景用原生循环，需要灵活性时用推送式迭代器。

什么时候需要迭代器？

基于以上分析，以下情况考虑使用迭代器：

1. 自定义复杂数据结构（树、图、链表等）
2. 大数据集处理（文件、数据库查询结果）
3. 无限序列或惰性求值
4. 需要统一遍历接口的多态代码
5. 流式数据处理链

而对于简单的切片、map遍历，直接使用内置的for range通常是最佳选择。

写在最后

Go语言中确实需要迭代器，但不是在所有场景下。迭代器是一种重要的抽象工具，它解决了自定义数据结构遍历、大数据处理和多态代码的需求。

随着Go 1.23迭代器特性的引入，我们现在有了更官方、更高效的迭代器实现方式。然而，没有银弹，在简单场景下直接使用内置的for range仍然是最佳选择。

迭代器是Go语言工具箱中有价值的一员，它体现了"适度抽象"的思想——在保持语言简洁性的同时，为复杂场景提供了必要的抽象能力。