了解 Go 中的迭代器：一次有趣的探索！

如果您是一名 Go 程序员，您可能在 Go 1.22 中多次听说过迭代器，尤其是在 Go 1.23 中。但也许您仍然摸不着头脑，想知道它们为什么有用或者何时应该使用它们。嗯，您来对地方了！让我们首先了解迭代器在 Go 中的工作原理以及它们为何如此有用。

一个简单的转换：还没有迭代器

假设我们有一个数字列表，我们希望将每个数字加倍。我们可以使用如下所示的简单函数来完成此操作：

package main

import (
    "fmt"
)

func NormalTransform[T1, T2 any](list []T1, transform func(T1) T2) []T2 {
    transformed := make([]T2, len(list))

    for i, t := range list {
        transformed[i] = transform(t)
    }

    return transformed
}

func main() {
    list := []int{1, 2, 3, 4, 5}
    doubleFunc := func(i int) int { return i * 2 }

    for i, num := range NormalTransform(list, doubleFunc) {
        fmt.Println(i, num)
    }
}

运行此代码时会发生以下情况：

0 2
1 4
2 6
3 8
4 10

很简单，对吧？这是一个基本的通用 Go 函数，它接受任何类型 T1 的列表，对每个元素应用转换函数，并返回一个新列表，其中包含任何类型 T2 的转换后的列表。如果您了解 Go 泛型！

，那么很容易理解

但是如果我告诉你还有另一种方法来处理这个问题——使用迭代器呢？

输入迭代器！

现在，让我们看看如何使用迭代器进行相同的转换：

package main

import (
    "fmt"
)

func IteratorTransform[T1, T2 any](list []T1, transform func(T1) T2) iter.Seq2[int, T2] {
    return func(yield func(int, T2) bool) {
        for i, t := range list {
            if !yield(i, transform(t)) {
                return
            }
        }
    }
}

func main() {
    list := []int{1, 2, 3, 4, 5}
    doubleFunc := func(i int) int { return i * 2 }

    for i, num := range NormalTransform(list, doubleFunc) {
        fmt.Println(i, num)
    }
}

运行之前，您必须确保您的 Go 版本是 1.23。输出完全相同：

0 2
1 4
2 6
3 8
4 10

但是等等，为什么我们需要一个迭代器？那不是更复杂吗？让我们深入探讨一下差异。

为什么使用迭代器？

乍一看，对于像转换列表这样简单的事情，迭代器似乎有点过度设计。但当您运行基准测试时，您就会开始明白为什么它们值得考虑！

让我们对这两种方法进行基准测试，看看它们的表现如何：

package main

import (
    "testing"
)

var (
    transform = func(i int) int { return i * 2 }
    list      = []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
)

func BenchmarkNormalTransform(b *testing.B) {
    for i := 0; i < b.N; i++ {
        NormalTransform(list, transform)
    }
}

func BenchmarkIteratorTransform(b *testing.B) {
    for i := 0; i < b.N; i++ {
        IteratorTransform(list, transform)
    }
}

这是初始基准测试结果：

BenchmarkNormalTransform-8      41292933                29.49 ns/op
BenchmarkIteratorTransform-8    1000000000               0.3135 ns/op

哇！这是一个巨大的差异！但是等等——这里有一点不公平。 NormalTransform 函数返回一个完全转换的列表，而 IteratorTransform 函数仅设置迭代器，尚未转换列表。

让我们通过完全循环迭代器来使其公平：

func BenchmarkIteratorTransform(b *testing.B) {
    for i := 0; i < b.N; i++ {
        for range IteratorTransform(list, transform) {
        }
    }
}

现在结果更加合理了：

BenchmarkNormalTransform-8      40758822                29.16 ns/op
BenchmarkIteratorTransform-8    53967146                22.39 ns/op

好吧，迭代器有点快。为什么？因为 NormalTransform 在返回之前会在内存中（在堆上）创建一个完整的转换列表，而迭代器会在循环遍历它时进行转换，从而节省时间和内存。

在此处阅读有关堆栈和堆的更多信息

当你不需要处理整个列表时，迭代器的真正魔力就会发生。让我们对一个场景进行基准测试，在转换列表后我们只想找到数字 4：

func BenchmarkNormalTransform(b *testing.B) {
    for i := 0; i < b.N; i++ {
        for _, num := range NormalTransform(list, transform) {
            if num == 4 {
                break
            }
        }
    }
}

func BenchmarkIteratorTransform(b *testing.B) {
    for i := 0; i < b.N; i++ {
        for _, num := range IteratorTransform(list, transform) {
            if num == 4 {
                break
            }
        }
    }
}

结果不言而喻：

package main

import (
    "fmt"
)

func NormalTransform[T1, T2 any](list []T1, transform func(T1) T2) []T2 {
    transformed := make([]T2, len(list))

    for i, t := range list {
        transformed[i] = transform(t)
    }

    return transformed
}

func main() {
    list := []int{1, 2, 3, 4, 5}
    doubleFunc := func(i int) int { return i * 2 }

    for i, num := range NormalTransform(list, doubleFunc) {
        fmt.Println(i, num)
    }
}

在这种情况下，迭代器要快得多！为什么？因为迭代器不会转换整个列表 - 一旦找到您要查找的结果，它就会停止。另一方面，即使我们只关心一项，NormalTransform 仍然会转换整个列表。

结论：何时使用迭代器？

那么，为什么在 Go 中使用迭代器？

• 效率：如果不需要，迭代器可以不处理整个列表，从而节省时间和内存。
• 灵活性：它们使您能够有效地处理大型数据集，特别是在处理数据流或需要提前停止时。 但请记住，迭代器的理解和实现可能有点棘手。当您需要额外的性能提升时，尤其是在您不需要预先处理整个列表的情况下，请使用它们。

迭代器：它们快速、灵活且有趣——一旦你掌握了它们！

以上是了解 Go 中的迭代器：一次有趣的探索！的详细内容。更多信息请关注PHP中文网其他相关文章！