Go迭代器完全指南：从基础到实战

Go迭代器完全指南：从基础到实战（Go 1.23+）

Go 1.23版本引入的range over func特性，让自定义迭代器成为可能，解决了传统for range仅支持内置类型（数组、切片、map等）的局限性。本文将全面讲解Go迭代器的核心概念、实现方式、标准库应用及实战技巧。

一、迭代器是什么？为什么需要它？

在Go 1.23之前，for range只能迭代内置类型（如切片、map、通道等），对于自定义数据结构（如链表、树、自定义容器），需要手动实现遍历逻辑，代码冗余且不统一。

迭代器通过range over func特性，允许我们为任意数据结构定义遍历规则，使自定义类型也能像内置类型一样使用for range迭代。其核心是将遍历逻辑封装为函数，通过回调函数（yield）逐个返回元素。

二、迭代器基础：推送式迭代器

推送式迭代器（Pushing Iterator）是Go迭代器的核心形式，由迭代器主动将元素"推送"给回调函数，通过for range直接使用。

1. 基本定义与用法

Go迭代器本质是一个接受yield回调函数的函数，官方通过iter标准库定义了两种常用迭代器类型：

// 单元素迭代器：每次返回一个值V
type Seq[V any] func(yield func(V) bool)// 键值对迭代器：每次返回两个值K和V
type Seq2[K, V any] func(yield func(K, V) bool)

• yield函数：迭代器通过调用yield传递元素，返回true表示继续迭代，false表示终止。
• for range会自动将循环体转换为yield回调，简化调用。

2. 示例：斐波那契数列迭代器

实现一个生成前n个斐波那契数的迭代器：

import "iter"// 生成前n个斐波那契数的迭代器
func Fibonacci(n int) iter.Seq[int] {a, b, c := 0, 1, 1 // 初始化斐波那契数列的前三项return func(yield func(int) bool) {for range n { // 迭代n次if !yield(a) { // 推送当前元素a，若yield返回false则终止return}// 更新斐波那契数列a, b = b, cc = a + b}}
}// 使用迭代器
func main() {// 用for range直接迭代，循环体即yield回调for f := range Fibonacci(8) {fmt.Println(f)}
}

输出：

0
1
1
2
3
5
8
13

3. 迭代器与for range的等价转换

for range迭代迭代器的本质是调用迭代器函数，并将循环体作为yield回调传入：

// 以下两种写法等价
for f := range Fibonacci(8) {fmt.Println(f)
}// 等价于直接调用迭代器函数，传入匿名函数作为yield
Fibonacci(8)(func(f int) bool {fmt.Println(f)return true // 返回true继续迭代
})

三、拉取式迭代器

拉取式迭代器（Pulling Iterator）由用户主动控制迭代过程，通过next()函数获取下一个元素，stop()函数终止迭代。Go标准库提供iter.Pull和iter.Pull2将推送式迭代器转换为拉取式。

1. 基本定义与用法

// 将iter.Seq转换为拉取式迭代器
func Pull[V any](seq iter.Seq[V]) (next func() (V, bool), stop func())// 将iter.Seq2转换为拉取式迭代器（键值对）
func Pull2[K, V any](seq iter.Seq2[K, V]) (next func() (K, V, bool), stop func())

• next()：返回下一个元素及有效性（bool），无效时表示迭代结束。
• stop()：终止迭代并释放资源（需确保调用，建议用defer）。

2. 示例：拉取式斐波那契迭代器

func main() {// 将推送式迭代器转换为拉取式next, stop := iter.Pull(Fibonacci(5))defer stop() // 确保迭代结束后释放资源// 主动调用next()获取元素for {fib, ok := next()if !ok {break // 迭代结束}fmt.Println(fib)}
}

输出：

0
1
1
2
3

3. 适用场景

拉取式迭代器适合需要手动控制迭代节奏的场景（如按需获取元素），但性能低于推送式，通常用于：

• 转换现有推送式迭代器以兼容拉取逻辑；
• 需中途暂停/恢复迭代的场景。

四、错误处理

迭代过程中若发生错误（如文件读取失败），可通过yield函数将错误作为返回值传递，由调用者处理。

示例：带错误处理的行迭代器

import ("bufio""io""iter"
)// 从io.Reader迭代行，返回行内容和错误
func ScanLines(reader io.Reader) iter.Seq2[string, error] {scanner := bufio.NewScanner(reader)return func(yield func(string, error) bool) {for scanner.Scan() {// 推送行内容和可能的错误if !yield(scanner.Text(), scanner.Err()) {return}}}
}// 使用迭代器
func main() {file, _ := os.Open("test.txt")defer file.Close()// 迭代时检查错误for line, err := range ScanLines(file) {if err != nil {fmt.Println("错误：", err)break}fmt.Println("行内容：", line)}
}

五、标准库中的迭代器

Go 1.23+的slices和maps包提供了丰富的迭代器工具函数，简化常用数据结构的遍历与处理。

1. slices包常用函数

函数	作用	示例
slices.All(s)	返回切片的键值对迭代器（索引+元素）	for i, v := range slices.All([]int{1,2})
slices.Values(s)	返回切片的元素迭代器（仅元素）	for v := range slices.Values([]int{1,2})
slices.Chunk(s, n)	将切片按n个元素分组，返回组迭代器	for chunk := range slices.Chunk([]int{1,2,3}, 2) → [1,2]、[3]
slices.Collect(seq)	将迭代器收集为切片	s := slices.Collect(slices.Values([]int{1,2})) → [1,2]

2. maps包常用函数

函数	作用	示例
maps.All(m)	返回map的键值对迭代器	for k, v := range maps.All(map[string]int{"a":1})
maps.Keys(m)	返回map的键迭代器	for k := range maps.Keys(map[string]int{"a":1})
maps.Values(m)	返回map的值迭代器	for v := range maps.Values(map[string]int{"a":1})
maps.Collect(seq)	将迭代器收集为map	m := maps.Collect(maps.All(map[string]int{"a":1}))

示例：用标准库函数处理数据流

import ("maps""slices"
)func main() {m := map[string]int{"one": 1, "two": 2, "three": 3}// 1. 提取map的键并排序keys := slices.Collect(maps.Keys(m))slices.Sort(keys)fmt.Println("排序后的键：", keys) // [one three two]// 2. 提取map的值并求和sum := 0for v := range maps.Values(m) {sum += v}fmt.Println("值的和：", sum) // 6
}

六、链式调用实现

Go迭代器本身不支持链式调用（如iter.Filter().Map()），但可通过结构体封装迭代器，实现类似"流式处理"的链式API。

示例：自定义链式迭代器

package iterximport ("iter""slices"
)// 封装迭代器的结构体
type SliceSeq[E any] struct {seq iter.Seq2[int, E] // 底层迭代器
}// 从切片创建链式迭代器
func Slice[S ~[]E, E any](s S) SliceSeq[E] {return SliceSeq[E]{seq: slices.All(s)}
}// 过滤元素（保留符合条件的元素）
func (s SliceSeq[E]) Filter(filter func(int, E) bool) SliceSeq[E] {return SliceSeq[E]{seq: func(yield func(int, E) bool) {i := 0 // 重新计算索引for k, v := range s.seq {if filter(k, v) {if !yield(i, v) {return}i++}}},}
}// 转换元素（对每个元素应用mapFn）
func (s SliceSeq[E]) Map(mapFn func(E) E) SliceSeq[E] {return SliceSeq[E]{seq: func(yield func(int, E) bool) {for k, v := range s.seq {if !yield(k, mapFn(v)) {return}}},}
}// 收集为切片
func (s SliceSeq[E]) Collect() []E {return slices.Collect(func(yield func(E) bool) {for _, v := range s.seq {yield(v)}})
}

链式调用使用示例

func main() {s := []int{1, 2, 3, 4, 5}// 链式调用：过滤偶数 → 乘以2 → 收集结果result := iterx.Slice(s).Filter(func(i, e int) bool { return e%2 == 0 }). // 保留偶数：2,4Map(func(e int) int { return e * 2 }). // 乘以2：4,8Collect()fmt.Println(result) // [4, 8]
}

七、性能对比

基准测试（遍历10000元素切片）结果：

方式	性能（ns/op）	说明
原生for range	~2400	最快，无额外开销
推送式迭代器（slices.All）	~3700	比原生慢约50%，适合大多数场景
拉取式迭代器（iter.Pull2）	~570000	比原生慢两个数量级，仅在必要时使用

结论：

• 性能敏感场景优先用原生for range；
• 需自定义遍历逻辑时用推送式迭代器；
• 拉取式迭代器仅用于特殊场景（如手动控制迭代）。

八、小结

Go迭代器通过range over func特性极大提升了自定义数据结构的遍历灵活性，核心优势包括：

1. 统一遍历接口，使自定义类型支持for range；
2. 标准库工具函数简化常见操作（如切片分组、map键值提取）；
3. 可通过链式调用实现流式数据处理。

但也存在局限性：

• 性能略低于原生循环，拉取式迭代器开销较大；
• 闭包实现的迭代器可读性较差，调试难度增加；
• 社区对其复杂性存在争议（违背Go的简洁哲学）。

合理使用迭代器的关键是：在灵活性与性能、可读性之间平衡，优先在通用组件（如数据结构库）中使用，简单场景仍推荐原生循环。