如果您是Go 程式設(shè)計(jì)師，您可能在Go 1.22 中多次聽說過迭代器，尤其是在Go 1.23 中。但也許您仍然摸不著頭腦，想知道為什麼它們有用或何時(shí)應(yīng)該使用它們。嗯，您來對地方了！讓我們先了解迭代器在 Go 中的工作原理以及為何它們?nèi)绱擞杏谩?

一個(gè)簡單的轉(zhuǎn)換：還沒有迭代器

假設(shè)我們有一個(gè)數(shù)字列表，我們希望將每個(gè)數(shù)字加倍。我們可以使用如下所示的簡單函數(shù)來完成此操作：

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

執(zhí)行此程式碼時(shí)會(huì)發(fā)生以下情況：

0 2
1 4
2 6
3 8
4 10

很簡單，對吧？這是一個(gè)基本的通用 Go 函數(shù)，它接受任何類型 T1 的列表，對每個(gè)元素套用轉(zhuǎn)換函數(shù)，並傳回一個(gè)新列表，其中包含任何類型 T2 的轉(zhuǎn)換後的列表。如果您了解 Go 泛型！

，那麼很容易理解

但是如果我告訴你還有另一種方法來處理這個(gè)問題－使用迭代器呢？

輸入迭代器！

現(xiàn)在，讓我們看看如何使用迭代器進(jìn)行相同的轉(zhuǎn)換：

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

在運(yùn)行之前，您必須確保您的 Go 版本是 1.23。輸出完全相同：

0 2
1 4
2 6
3 8
4 10

但是等等，為什麼我們需要一個(gè)迭代器？那不是更複雜嗎？讓我們深入探討一下差異。

為什麼要使用迭代器？

乍一看，對於像轉(zhuǎn)換清單這樣簡單的事情，迭代器似乎有點(diǎn)過度設(shè)計(jì)。但當(dāng)您執(zhí)行基準(zhǔn)測試時(shí)，您就會(huì)開始明白為什麼它們值得考慮！

讓我們對這兩種方法進(jìn)行基準(zhǔn)測試，看看它們的表現(xiàn)如何：

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

這是初步基準(zhǔn)測試結(jié)果：

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

哇！這是一個(gè)巨大的差異！但是等等——這裡有一點(diǎn)不公平。 NormalTransform 函數(shù)傳回一個(gè)完全轉(zhuǎn)換的列表，而 IteratorTransform 函數(shù)僅設(shè)定迭代器，尚未轉(zhuǎn)換列表。

讓我們透過完全循環(huán)迭代器來使其公平：

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

現(xiàn)在結(jié)果更合理了：

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

好吧，迭代器有點(diǎn)快。為什麼？因?yàn)?NormalTransform 在返回之前會(huì)在記憶體中（在堆上）創(chuàng)建一個(gè)完整的轉(zhuǎn)換列表，而迭代器會(huì)在循環(huán)遍歷它時(shí)進(jìn)行轉(zhuǎn)換，從而節(jié)省時(shí)間和記憶體。

在此閱讀更多關(guān)於堆疊和堆疊的更多資訊

當(dāng)你不需要處理整個(gè)清單時(shí)，迭代器的真正魔力就會(huì)發(fā)生。讓我們對一個(gè)場景進(jìn)行基準(zhǔn)測試，在轉(zhuǎn)換清單後我們只想找到數(shù)字 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
            }
        }
    }
}

結(jié)果不言而喻：

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

在這種情況下，迭代器快得多！為什麼？因?yàn)榈鞑粫?huì)轉(zhuǎn)換整個(gè)清單 - 一旦找到您要尋找的結(jié)果，它就會(huì)停止。另一方面，即使我們只關(guān)心一項(xiàng)，NormalTransform 仍然會(huì)轉(zhuǎn)換整個(gè)清單。

結(jié)論：何時(shí)使用迭代器？

那麼，為什麼在 Go 中使用迭代器？

• 效率：如果不需要，迭代器可以不處理整個(gè)列表，從而節(jié)省時(shí)間和記憶體。
• 靈活性：它們使您能夠有效地處理大型資料集，特別是在處理資料流或需要提前停止時(shí)。 但請記住，迭代器的理解和實(shí)作可能有點(diǎn)棘手。當(dāng)您需要額外的效能提升時(shí)，尤其是在您不需要預(yù)先處理整個(gè)清單的情況下，請使用它們。

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

以上是了解 Go 中的迭代器：有趣的探索！的詳細(xì)內(nèi)容。更多資訊請關(guān)注PHP中文網(wǎng)其他相關(guān)文章！