理解 Go 迭代器-Golang-PHP中文网

理解 Go 迭代器

WBOY

发布： 2024-08-18 09:20:28

转载

280人浏览过

理解 go 迭代器

很多人似乎对 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 实现来检查这一点，但根据我的观察，它们确实产生了相同的结果。

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

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

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

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

智慧车行预约小程序

智慧车行小程序，是一个专门为洗车/4S/车辆维修行业打造的小程序，前后端完整代码包括车行动态，养车常识，保养预约，维修预约，洗车美容预约，汽车检测预约等功能。采用腾讯提供的小程序云开发解决方案，无须服务器和域名预约管理：开始/截止时间/人数均可灵活设置，可以自定义客户预约填写的数据项预约凭证：支持线下到场后校验签到/核销/二维码自助签到等多种方式详尽的预约数据：支持预约名单数据导出Excel，打印

查看详情

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
    //  })
}

登录后复制

以上就是理解 Go 迭代器的详细内容，更多请关注php中文网其它相关文章！