Исполняемые доки Go: Циклы range

Q: Что возвращает range в Go?

Зависит от операнда. Для слайса или массива: индекс и элемент. Для строки: индекс байта и руну. Для мапы: ключ и значение. Для канала: каждое полученное значение. Для целого числа n (Go 1.22): от 0 до n минус 1. Для функции-итератора (Go 1.23): то, что отдаёт функция. Вторую переменную можно опустить, а первую отбросить через _.

Q: Почему изменение значения в range не меняет мой слайс?

Переменная значения это копия элемента. for _, v := range items { v.Price = 0 } меняет только копию. Используйте индекс: for i := range items { items[i].Price = 0 } или обходите слайс указателей.

Q: Можно ли делать range по целому числу в Go?

Да, начиная с Go 1.22: for i := range 5 { ... } выполняется с i от 0 до 4. for range 5 { ... } повторяет тело пять раз без переменной. В go.mod модуля должно быть указано go 1.22 или новее.

Q: Безопасно ли удалять из map во время range?

Да. Удалённая запись, до которой обход ещё не дошёл, просто не будет выдана, а удалять текущую запись можно. Добавлять записи во время цикла тоже разрешено, но новая запись может попасть в обход, а может и нет, так что на это не полагайтесь.

range это форма for, которая проходит по коллекции. На каждой итерации она выдаёт одно или два значения, и какие именно, зависит от типа, который вы обходите:

Операнд	Первое значение	Второе значение	Примечания
слайс `[]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 {} самый короткий способ повторить что-то три раза.

Значение это копия

На каждой итерации элемент копируется в переменную значения. Изменение переменной не меняет коллекцию:

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. Первое значение это смещение в байтах, с которого начинается каждый символ, поэтому числа могут идти с пропусками:

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++, или range по []byte(s). Подробности про 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)
}

Удалять записи во время обхода безопасно, и удалённая запись, до которой обход ещё не дошёл, выдана не будет. Добавлять записи можно, но результат непредсказуем: новый ключ может появиться позже в том же цикле, а может и нет. 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. Тип переменной цикла совпадает с типом 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 цикл тоже выполнится ноль раз. 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()
}

Добавленное 99 не обходится, потому что длина цикла зафиксирована на 3. А вот nums[2] = 30 видно, потому что в этот момент nums всё ещё разделяет базовый массив со слайсом, который обходится. Поменяйте две строки местами, и 30 тоже пропадёт: append превышает ёмкость 3, выделяет новый массив, и запись попадает туда. Обход массива по значению сначала копирует весь массив, поэтому изменение arr[2] не видно; чтобы избежать копии, обходите &arr или arr[:].

range по функциям (Go 1.23)

Начиная с Go 1.23 range принимает и функции-итераторы. Итератор получает колбэк yield, вызывает его по разу на каждое значение и останавливается, когда 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] это стандартные имена двух форм итератора. Стандартная библиотека возвращает их из slices.All, slices.Values, slices.Backward, maps.Keys, maps.Values, maps.All, а в Go 1.24 из strings.SplitSeq, strings.Lines и bytes.SplitSeq. Итератор обязан учитывать результат yield: повторный вызов yield после того, как он вернул false, вызывает панику.

Переменные цикла своя на каждой итерации (Go 1.22)

Начиная с Go 1.22 переменные, объявленные в for ... range, создаются заново на каждой итерации. Захват v в замыкании или горутине захватывает значение этой итерации, а не общую переменную, в которой в итоге окажется последний элемент. До Go 1.22 внутри цикла нужна была строка v := v; теперь она лишняя. Правило определяется версией go в go.mod, поэтому старый модуль сохраняет старое поведение.

Частые ошибки

Взятие адреса переменной значения. До Go 1.22 ptrs = append(ptrs, &v) каждый раз сохранял один и тот же адрес. Начиная с 1.22 адреса разные, но каждый указывает на копию, а не на элемент слайса. Чтобы указывать внутрь слайса, используйте &items[i].
Расчёт на порядок в мапе. Вывод, который выглядит отсортированным в маленьком тесте, отсортированным не останется.
range по каналу, который никто не закрывает. Цикл и горутина, в которой он выполняется, ждут вечно.
range по большому массиву по значению. Сначала копируется весь массив. Обходите его слайс.

Часто задаваемые вопросы

Что возвращает range в Go?

Зависит от операнда. Для слайса или массива: индекс и элемент. Для строки: индекс байта и руну. Для мапы: ключ и значение. Для канала: каждое полученное значение. Для целого числа n (Go 1.22): от 0 до n минус 1. Для функции-итератора (Go 1.23): то, что отдаёт функция. Вторую переменную можно опустить, а первую отбросить через _.

Почему изменение значения в range не меняет мой слайс?

Переменная значения это копия элемента. for _, v := range items { v.Price = 0 } меняет только копию. Используйте индекс: for i := range items { items[i].Price = 0 } или обходите слайс указателей.

Можно ли делать range по целому числу в Go?

Да, начиная с Go 1.22: for i := range 5 { ... } выполняется с i от 0 до 4. for range 5 { ... } повторяет тело пять раз без переменной. В go.mod модуля должно быть указано go 1.22 или новее.

Безопасно ли удалять из map во время range?

Да. Удалённая запись, до которой обход ещё не дошёл, просто не будет выдана, а удалять текущую запись можно. Добавлять записи во время цикла тоже разрешено, но новая запись может попасть в обход, а может и нет, так что на это не полагайтесь.

Связанные концепции