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, c
            c = 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包常用函数

2. maps包常用函数

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

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 := 0
    for v := range maps.Values(m) {
        sum += v
    }
    fmt.Println("值的和：", sum) // 6
}

六、链式调用实现

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

示例：自定义链式迭代器

package iterx

import (
    "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,4
        Map(func(e int) int { return e * 2 }). // 乘以2：4,8
        Collect()

    fmt.Println(result) // [4, 8]
}

七、性能对比

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

结论：

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

八、小结

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

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

但也存在局限性：

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

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