Go プログラマーであれば、おそらく Go 1.22、特に Go 1.23 でイテレーターについて何度も聞いたことがあるでしょう。 。しかし、なぜそれらが役立つのか、いつ使用する必要があるのか??、まだ頭を悩ませているかもしれません。そうですね、あなたは正しい場(chǎng)所にいます！まずは、Go でイテレータがどのように機(jī)能するのか、そしてなぜイテレータが非常に役立つのかを見(jiàn)てみましょう。

単純な変換: イテレータはまだありません

數(shù)値のリストがあり、それぞれの數(shù)値を 2 倍にしたいと想像してください。以下のような簡(jiǎn)単な関數(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)
    }
}

このコードを?qū)g行すると、次のことが起こります:

0 2
1 4
2 6
3 8
4 10

とてもシンプルですよね?これは基本的な汎用 Go 関數(shù)で、任意の型 T1 のリストを受け取り、各要素に変換関數(shù)を適用して、任意の型 T2 の変換されたリストを含む新しいリストを返します。 Goジェネリックを知っていれば簡(jiǎn)単に理解できます!

しかし、これを処理する別の方法、つまりイテレータを使用する方法があると言ったらどうなるでしょうか?

イテレータを入力してください!

ここで、同じ変換にイテレータを使用する方法を見(jià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)
    }
}

実行する前に、Go のバージョンが 1.23 であることを確認(rèn)する必要があります。出力はまったく同じです:

0 2
1 4
2 6
3 8
4 10

しかし、待ってください、なぜここでイテレータが必要なのでしょうか?それはもっと複雑ではないでしょうか？違いを詳しく見(jiàn)てみましょう。

イテレータを使用する理由

一見(jiàn)すると、イテレーターは、リストの変換のような単純なことに対して少し過(guò)剰設(shè)計(jì)されているように見(jiàn)えます。しかし、ベンチマークを?qū)g行すると、ベンチマークを検討する価値がある理由が分かり始めます!

両方のメソッドをベンチマークして、そのパフォーマンスを確認(rè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)
    }
}

最初のベンチマーク結(jié)果は次のとおりです:

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

おお！それは大きな違いです！しかし、ちょっと待ってください。ここには少し不公平があります。 NormalTransform 関數(shù)は完全に変換されたリストを返しますが、IteratorTransform 関數(shù)はリストをまだ変換せずに反復(fù)子を設(shè)定するだけです。

イテレータを完全にループして公平にしましょう:

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

結(jié)果はより合理的になりました:

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

わかりました、イテレーターは少し高速です。なぜ？ NormalTransform は、変換されたリスト全體をメモリ (ヒープ上) に作成してから返しますが、反復(fù)子はループ処理中に変換を?qū)g行するため、時(shí)間とメモリが節(jié)約されます。

スタックとヒープ について詳しくは、こちらをご覧ください

イテレータの本當(dāng)の魔法は、リスト全體を処理する必要がないときに起こります。リストを変換した後に數(shù)字の 4 だけを見(jiàn)つけたいというシナリオのベンチマークを行ってみましょう:

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é)果がすべてを物語(yǔ)っています:

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

この場(chǎng)合、反復(fù)子ははるかに高速です。なぜ？イテレーターはリスト全體を変換するわけではないため、探している結(jié)果が見(jiàn)つかるとすぐに停止します。一方、NormalTransform は、たとえ 1 つの項(xiàng)目だけを?qū)澫螭趣筏皮狻ⅴ辚攻热wを変換します。

結(jié)論: イテレータをいつ使用するか?

それでは、なぜ Go でイテレータを使用するのでしょうか?

• 効率: イテレータは、必要がない場(chǎng)合にリスト全體を処理しないことで、時(shí)間とメモリの両方を節(jié)約できます。
• 柔軟性: 特にデータのストリームを扱う場(chǎng)合や早期に停止する必要がある場(chǎng)合に、大規(guī)模なデータセットを効率的に処理できるようになります。 ただし、イテレーターは理解して実裝するのが少し難しい場(chǎng)合があることに注意してください。追加のパフォーマンス向上が必要な場(chǎng)合、特にリスト全體を事前に処理する必要がないシナリオでこれらを使用してください。

イテレーター: コツを摑めば、高速かつ柔軟で楽しいです!

以上がGo のイテレータを理解する: 楽しいダイビング!の詳細(xì)內(nèi)容です。詳細(xì)については、PHP 中國(guó)語(yǔ) Web サイトの他の関連記事を參照してください。