実行できるGoドキュメント: rangeループ

Q: Goのrangeは何を返しますか？

オペランドによって決まります。スライスや配列ならインデックスと要素、文字列ならバイトインデックスとルーン、マップならキーと値、チャネルなら受信した各値、整数 n（Go 1.22）なら0からn-1、イテレータ関数（Go 1.23）なら関数が渡すものです。2つ目の変数は省略でき、1つ目は _ で捨てられます。

Q: なぜrangeの値を変更してもスライスが変わらないのですか？

値の変数は要素のコピーだからです。for _, v := range items { v.Price = 0 } はコピーだけを変更します。代わりにインデックスを使うか：for i := range items { items[i].Price = 0 }、ポインタのスライスに対してrangeします。

Q: Goで整数に対してrangeできますか？

Go 1.22からできます：for i := range 5 { ... } は i を0から4まで動かして実行します。for range 5 { ... } は変数なしで5回繰り返します。モジュールの go.mod が go 1.22 以降を指定している必要があります。

Q: rangeしている最中にマップから削除しても安全ですか？

安全です。まだ到達していないエントリを削除すれば、それは返されなくなり、現在のエントリを削除しても問題ありません。ループ中にエントリを追加することも許されますが、新しいエントリが走査されるかどうかはわからないので、それに頼ってはいけません。

range は、コレクションをたどる形の for です。反復ごとに1つまたは2つの値が得られ、その値が何になるかはrangeする型によって決まります。

オペランド	1つ目の値	2つ目の値	備考
スライス `[]T`、配列 `[n]T`	インデックス `int`	要素 `T`、コピー
配列へのポインタ `*[n]T`	インデックス	要素
文字列	バイトインデックス `int`	`rune`	UTF-8をデコードする
マップ `map[K]V`	キー `K`	値 `V`	順序はランダム
チャネル `chan T`	要素 `T`	なし	チャネルが閉じられるまで
整数 `n`	0からn-1	なし	Go 1.22
`func(yield func() bool)`	なし	なし	Go 1.23
`func(yield func(V) bool)`	`V`	なし	Go 1.23
`func(yield func(K, V) bool)`	`K`	`V`	Go 1.23

package main

import "fmt"

func main() {
	for i, s := range []string{"a", "b"} {
		fmt.Println("slice", i, s)
	}
	for i, r := range "hé" {
		fmt.Println("string", i, string(r))
	}
	for k, v := range map[string]int{"x": 1} {
		fmt.Println("map", k, v)
	}
	ch := make(chan int, 2)
	ch <- 10
	ch <- 20
	close(ch)
	for v := range ch {
		fmt.Println("channel", v)
	}
	for i := range 2 {
		fmt.Println("int", i)
	}
}

受け取る変数を選ぶ

for i, v := range s {}  // both
for i := range s {}     // index (or key) only
for _, v := range s {}  // value only
for range s {}          // neither: just repeat len(s) times

使わない変数を宣言するとコンパイルエラーになるので、不要なものは省くか _ にします。for range 3 {} は、何かを3回繰り返す最も短い書き方です。

値はコピー

反復のたびに、要素が値の変数にコピーされます。変数を変更しても、コレクションは変わりません。

package main

import "fmt"

type Item struct {
	Name  string
	Price int
}

func main() {
	items := []Item{{"pen", 3}, {"book", 12}}

	for _, it := range items {
		it.Price *= 2 // changes the copy
	}
	fmt.Println(items)

	for i := range items {
		items[i].Price *= 2 // changes the element
	}
	fmt.Println(items)

	ptrs := []*Item{{"cup", 5}}
	for _, p := range ptrs {
		p.Price = 1 // p is a copy of the pointer, but points at the real Item
	}
	fmt.Println(*ptrs[0])
}

要素が大きな構造体だと、コピーには時間もかかります。大きな構造体のスライスでは、for i := range s と s[i] を使えばコピーを避けられます。

文字列はルーンを返す

文字列に対するrangeはUTF-8をデコードします。1つ目の値は各文字が始まる バイト オフセットなので、数字が飛ぶことがあります。

package main

import "fmt"

func main() {
	for i, r := range "añ語!" {
		fmt.Printf("byte %d: %c (U+%04X)\n", i, r, r)
	}

	// invalid UTF-8 yields U+FFFD and advances one byte
	for i, r := range "a\xffb" {
		fmt.Printf("byte %d: %q\n", i, r)
	}
}

文字ではなくバイトをたどるには、インデックスのループ for i := 0; i < len(s); i++ を使うか、[]byte(s) に対してrangeします。UTF-8の詳細はルーンとバイトのページを参照してください。

マップ：順序はランダム

マップの反復順は規定されておらず、コードが特定の順序に依存しないようにランタイムがランダムにしています。決まった順序で出力するには、キーをソートします。

package main

import (
	"fmt"
	"maps"
	"slices"
)

func main() {
	stock := map[string]int{"pears": 4, "apples": 10, "figs": 0}

	for _, k := range slices.Sorted(maps.Keys(stock)) {
		fmt.Println(k, stock[k])
	}

	// deleting during iteration is allowed
	for k, v := range stock {
		if v == 0 {
			delete(stock, k)
		}
	}
	fmt.Println(len(stock), stock)
}

rangeしながらエントリを削除するのは安全で、まだ到達していない削除済みのエントリは返されません。エントリの追加も許されていますが予測できません。新しいキーが同じループの後半で現れるかどうかはわかりません。マップを fmt.Println で表示するとキーがソートされるので、最後の行は安定しています。

チャネル：閉じられるまで

チャネルに対するrangeは、チャネルが閉じられて空になるまで値を受信します。誰も閉じなければループは永遠にブロックします（そしてすべてのゴルーチンがブロックすると、ランタイムは fatal error: all goroutines are asleep - deadlock! で停止します）。

package main

import "fmt"

func produce(n int) <-chan int {
	out := make(chan int)
	go func() {
		defer close(out) // without this, the range below never ends
		for i := range n {
			out <- i * i
		}
	}()
	return out
}

func main() {
	for sq := range produce(5) {
		fmt.Print(sq, " ")
	}
	fmt.Println()
}

チャネルを閉じるのは送信側で、受信側は決して閉じません。バッファ付きチャネルと select についてはチャネルのページを参照してください。

整数（Go 1.22）

range n は0から n の手前まで数えます。ループ変数の型は n の型になります。

for i := range 3 {}         // i is int: 0, 1, 2
for i := range uint8(3) {}  // i is uint8
for range 0 {}              // runs zero times

n が負の場合も0回実行されます。n はループが始まる前に一度だけ評価されます。

rangeが何をいつ評価するか

range の後ろの式は、最初の反復の前に 一度だけ 評価されます。スライスの場合、range はそのスライスヘッダーを使い続けるので、長さは固定されます。

package main

import "fmt"

func main() {
	nums := []int{1, 2, 3}
	for i, v := range nums {
		if i == 0 {
			nums[2] = 30            // visited: same backing array
			nums = append(nums, 99) // not visited
		}
		fmt.Print(v, " ")
	}
	fmt.Println()
	fmt.Println(nums)

	arr := [3]int{1, 2, 3}
	for i, v := range arr { // the array itself is copied
		if i == 0 {
			arr[2] = 30
		}
		fmt.Print(v, " ")
	}
	fmt.Println()
}

ループの長さが3に固定されたので、追加した 99 は走査されません。一方 nums[2] = 30 は見えます。その時点では nums が、rangeしているスライスと元の配列を共有しているからです。2行を入れ替えると 30 も見えなくなります。append が容量3を超えて新しい配列を確保し、書き込みはそちらに入るからです。配列の値に対するrangeは最初に配列全体をコピーするので、arr[2] への変更は見えません。コピーを避けるには &arr か arr[:] に対してrangeします。

関数に対するrange（Go 1.23）

Go 1.23から、range はイテレータ関数も受け付けます。イテレータは yield コールバックを受け取り、値ごとに1回それを呼び、yield が false を返したら止まります（ループ本体が break か return を実行するとそうなります）。

package main

import (
	"fmt"
	"iter"
	"maps"
	"slices"
)

// Countdown yields n, n-1, ..., 1.
func Countdown(n int) iter.Seq[int] {
	return func(yield func(int) bool) {
		for i := n; i > 0; i-- {
			if !yield(i) {
				return
			}
		}
	}
}

// Pairs yields adjacent pairs from a slice.
func Pairs(s []string) iter.Seq2[string, string] {
	return func(yield func(string, string) bool) {
		for i := 0; i+1 < len(s); i++ {
			if !yield(s[i], s[i+1]) {
				return
			}
		}
	}
}

func main() {
	for n := range Countdown(5) {
		if n == 2 {
			break // yield returns false, Countdown stops
		}
		fmt.Print(n, " ")
	}
	fmt.Println()

	for a, b := range Pairs([]string{"a", "b", "c"}) {
		fmt.Println(a, "->", b)
	}

	// standard library iterators
	for i, v := range slices.Backward([]string{"x", "y", "z"}) {
		fmt.Printf("%d:%s ", i, v)
	}
	fmt.Println()
	fmt.Println(slices.Sorted(maps.Values(map[string]int{"a": 3, "b": 1})))
}

iter.Seq[V] と iter.Seq2[K, V] は、2つのイテレータの形の標準的な名前です。標準ライブラリでは slices.All、slices.Values、slices.Backward、maps.Keys、maps.Values、maps.All がこれらを返し、Go 1.24では strings.SplitSeq、strings.Lines、bytes.SplitSeq も返します。イテレータは yield の戻り値を尊重しなければなりません。false が返った後に再び yield を呼ぶとpanicします。

ループ変数は反復ごと（Go 1.22）

Go 1.22以降、for ... range で宣言した変数は反復ごとに新しくなります。クロージャやゴルーチンで v を捕捉すると、最後の要素を保持することになる共有の変数ではなく、その反復の値を捕捉します。Go 1.22より前はループ内に v := v が必要でしたが、その行はもう不要です。このルールは go.mod の go のバージョンで決まるので、古いモジュールは古い挙動のままです。

よくある間違い

値の変数のアドレスを取る。 Go 1.22より前は、ptrs = append(ptrs, &v) は毎回同じアドレスを保存していました。1.22以降は別々のアドレスになりますが、どれもスライスの要素ではなくコピーを指しています。スライスの中を指すには &items[i] を使います。
マップの順序を期待する。 小さなテストでソートされているように見える出力も、ずっとソートされたままではありません。
誰も閉じないチャネルに対してrangeする。 ループと、それを実行しているゴルーチンは永遠に待ち続けます。
大きな配列を値でrangeする。 最初に配列全体がコピーされます。代わりにそのスライスに対してrangeします。

よくある質問

Goのrangeは何を返しますか？

オペランドによって決まります。スライスや配列ならインデックスと要素、文字列ならバイトインデックスとルーン、マップならキーと値、チャネルなら受信した各値、整数 n（Go 1.22）なら0からn-1、イテレータ関数（Go 1.23）なら関数が渡すものです。2つ目の変数は省略でき、1つ目は _ で捨てられます。

なぜrangeの値を変更してもスライスが変わらないのですか？

値の変数は要素のコピーだからです。for _, v := range items { v.Price = 0 } はコピーだけを変更します。代わりにインデックスを使うか：for i := range items { items[i].Price = 0 }、ポインタのスライスに対してrangeします。

Goで整数に対してrangeできますか？

Go 1.22からできます：for i := range 5 { ... } は i を0から4まで動かして実行します。for range 5 { ... } は変数なしで5回繰り返します。モジュールの go.mod が go 1.22 以降を指定している必要があります。

rangeしている最中にマップから削除しても安全ですか？

安全です。まだ到達していないエントリを削除すれば、それは返されなくなり、現在のエントリを削除しても問題ありません。ループ中にエントリを追加することも許されますが、新しいエントリが走査されるかどうかはわからないので、それに頼ってはいけません。