很多人似乎对 Go 中新添加的迭代器感到困惑，这就是为什么我决定再写一篇文章试图以尽可能简单的方式解释它们。

Go 是如何调用它们的？

首先，我认为了解 Go 是如何调用和使用迭代器的很重要，实际上很简单，让我们以 slices.All 迭代器为例。以下是通常如何使用此迭代器：

package main

import (
    "fmt"
    "slices"
)

func main() {
    slice := []string{
        "Element 1",
        "Element 2",
        "Element 3",
        "Element 4",
    }

    for index, element := range slices.All(slice) {
        if index >= 2 {
            break
        }
        fmt.Println(index, element)
    }

    // Output:
    // 0 Element 1
    // 1 Element 2
}

它实际上是这样的：

package main

import (
    "fmt"
    "slices"
)

func main() {
    slice := []string{
        "Element 1",
        "Element 2",
        "Element 3",
        "Element 4",
    }

    slices.All(slice)(func (index int, element string) bool {
        if index >= 2 {
            return false // break
        }
        fmt.Println(index, element)

        return true // continue loop as normal
    })

    // Output:
    // 0 Element 1
    // 1 Element 2
}

发生的情况是循环体被“移动”到传递给迭代器的yield 函数，而continue 和break 被转换为分别返回true 和return false。 return true 也被添加到循环的末尾，以表明我们想要获取下一个元素，如果之前没有其他决定的话。

这并不是编译器正在做什么的准确展开，我还没有检查 Go 实现来检查这一点，但根据我的观察，它们确实产生了等效的结果。

如何创建自己的迭代器及其执行

现在，您了解了它们是如何被调用并意识到它实际上是多么简单，那么理解如何创建自己的迭代器及其执行就会容易得多。

让我们创建一个调试迭代器，它将打印迭代器实现的每个步骤的调试消息，该迭代器实现将遍历切片中的所有元素（slices.All 功能）。

首先，我将创建一个小辅助函数来注销当前执行时间的消息。

import (
    "fmt"
    "time"
)

var START time.Time = time.Now()

func logt(message string) {
    fmt.Println(time.Since(START), message)
}

返回迭代器：

import (
    "iter"
)

func DebugIter[E any](slice []E) iter.Seq2[int, E] {
    logt("DebugIter called")

    // the same way iter.All returned function
    // we called in order to iterate over slice
    // here we are returning a function to
    // iterate over all slice elements too
    return func(yield func(int, E) bool) {
        logt("Seq2 return function called, starting loop")
        for index, element := range slice {
            logt("in loop, calling yield")
            shouldContinue := yield(index, element)
            if !shouldContinue {
                logt("in loop, yield returned false")
                return
            }
            logt("in loop, yield returned true")
        }
    }
}

我添加了一些调试打印语句，以便我们可以更好地查看迭代器的执行顺序以及它将如何对不同的关键字（如break和continue）做出反应。

最后，让我们使用实现的迭代器：

func main() {
    slice := []string{
        "Element 1",
        "Element 2",
        "Element 3",
        "Element 4",
    }

    for index, element := range DebugIter(slice) {
        message := "got element in range of iter: "   element
        logt(message)
        if index >= 2 {
            break
        }
        if index > 0 {
            continue
        }
        time.Sleep(2 * time.Second)
        logt("ended sleep in range of iter")
    }
}

会给我们输出：

11.125µs DebugIter called
39.292µs Seq2 return function called, starting loop
42.459µs in loop, calling yield
44.292µs got element in range of iter: Element 1
2.001194292s ended sleep in range of iter
2.001280459s in loop, yield returned true
2.001283917s in loop, calling yield
2.001287042s got element in range of iter: Element 2
2.001291084s in loop, yield returned true
2.001293125s in loop, calling yield
2.0012955s got element in range of iter: Element 3
2.001297542s in loop, yield returned false

这个例子很好地展示了迭代器是如何工作和执行的。当在范围循环中使用迭代器时，循环块中的所有指令都被“移动”到称为yield 的函数。当我们调用yield时，我们本质上是要求go运行时执行循环块中的任何内容，并在这次迭代中使用以下值，这也是如果循环体被阻塞，yield将被阻塞的原因。如果运行时确定该循环迭代应该停止，则yield将返回false，当循环块执行期间遇到break关键字时可能会发生这种情况，如果发生这种情况，我们不应该再调用yield。否则，我们应该继续调用yield.

完整代码：

package main

import (
    "fmt"
    "time"
    "iter"
)

var START time.Time = time.Now()

func logt(message string) {
    fmt.Println(time.Since(START), message)
}

func DebugIter[E any](slice []E) iter.Seq2[int, E] {
    logt("DebugIter called")

    // the same way iter.All returned function
    // we called in order to iterate over slice
    // here we are returning a function to
    // iterate over all slice elements too
    return func(yield func(int, E) bool) {
        logt("Seq2 return function called, starting loop")
        for index, element := range slice {
            logt("in loop, calling yield for")
            shouldContinue := yield(index, element)
            if !shouldContinue {
                logt("in loop, yield returned false")
                return
            }
            logt("in loop, yield returned true")
        }
    }
}

func main() {
    slice := []string{
        "Element 1",
        "Element 2",
        "Element 3",
        "Element 4",
    }

    for index, element := range DebugIter(slice) {
        message := "got element in range of iter: "   element
        logt(message)
        if index >= 2 {
            break
        }
        if index > 0 {
            continue
        }
        time.Sleep(2 * time.Second)
        logt("ended sleep in range of iter")
    }

    // unfold compiler magic
    //  DebugIter(slice)(func (index int, element string) bool {
    //    message := "got element in range of iter: "   element
    //    logt(message)
    //    if index >= 2 {
    //      return false
    //    }
    //    if index > 0 {
    //      return true
    //    }
    //    time.Sleep(2 * time.Second)
    //    logt("ended sleep in range of iter")
    //
    //    return true
    //  })
}