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

Q: Как написать цикл for в Go?

Классическая форма состоит из трёх частей через точку с запятой и пишется без круглых скобок: Начиная с Go 1.22 можно также написать for i := range 5, что считает от 0 до 4. Чтобы пройти по слайсу, используйте for i, v := range items.

Q: Есть ли в Go цикл while?

Ключевого слова while нет, но for с одним только условием и есть цикл while: for n > 0 { n /= 2 }. for { ... } без условия это бесконечный цикл, из которого выходят через break или return.

Q: Как перебрать map в Go?

for key, value := range m { ... }. Порядок обхода не определён, и среда выполнения его рандомизирует, так что он может отличаться от цикла к циклу. Никогда на него не полагайтесь. Для стабильного порядка соберите ключи, отсортируйте их через slices.Sort и пройдите по отсортированным ключам.

Q: Как выйти из вложенного цикла в Go?

Поставьте метку перед внешним циклом и укажите её в break: outer: for ... { for ... { if found { break outer } } }. Обычный break выходит только из самого внутреннего for, switch или select. continue outer аналогично переходит к следующей итерации помеченного цикла.

Q: Что изменилось с переменными цикла в Go 1.22?

До Go 1.22 у цикла for была одна переменная на все итерации, поэтому замыкания и горутины, запущенные в цикле, часто видели последнее значение. Начиная с Go 1.22 каждая итерация получает свою копию, и захват i или v в замыкании работает как ожидается. Новое поведение действует, когда в go.mod модуля указано go 1.22 или новее.

В Go ровно одно ключевое слово для циклов: for. У него четыре формы, и вместе они покрывают все циклы, которые в других языках пишут через for, while, do while или foreach.

package main

import "fmt"

func main() {
	// 1. three-clause loop
	for i := 0; i < 3; i++ {
		fmt.Println("count", i)
	}

	// 2. condition only (a while loop)
	n := 20
	for n > 1 {
		n /= 2
	}
	fmt.Println("n ended at", n)

	// 3. infinite loop with break
	tries := 0
	for {
		tries++
		if tries == 4 {
			break
		}
	}
	fmt.Println("tries:", tries)

	// 4. range
	for i, fruit := range []string{"apple", "kiwi"} {
		fmt.Println(i, fruit)
	}
}

Заголовок цикла не заключается в круглые скобки, а фигурные скобки обязательны всегда.

Цикл из трёх частей

for init; condition; post {
	// body
}

init выполняется один раз перед циклом. Обычно это короткое объявление переменной вроде i := 0, и эта переменная существует только внутри цикла.
condition проверяется перед каждой итерацией. Когда оно ложно, цикл заканчивается.
Выполняется тело.
post выполняется после каждой итерации, обычно это i++.

package main

import "fmt"

func main() {
	// count down
	for i := 5; i > 0; i-- {
		fmt.Print(i, " ")
	}
	fmt.Println("liftoff")

	// step by 10
	for x := 0; x <= 50; x += 10 {
		fmt.Print(x, " ")
	}
	fmt.Println()

	// two variables at once (parallel assignment in post)
	word := []rune("racecar")
	isPalindrome := true
	for i, j := 0, len(word)-1; i < j; i, j = i+1, j-1 {
		if word[i] != word[j] {
			isPalindrome = false
			break
		}
	}
	fmt.Println("racecar is a palindrome:", isPalindrome)
}

В Go i++ это инструкция, а не выражение, поэтому в post нельзя написать i++, j--. Вместо этого используйте параллельное присваивание: i, j = i+1, j-1.

Все три части необязательны. for ; i < 10; {} допустимо, и gofmt перепишет это в for i < 10 {}, то есть в следующую форму.

Цикл только с условием (while в Go)

С одним только условием for ведёт себя как while в других языках:

package main

import "fmt"

func main() {
	// Collatz sequence: how many steps to reach 1?
	n, steps := 27, 0
	for n != 1 {
		if n%2 == 0 {
			n /= 2
		} else {
			n = 3*n + 1
		}
		steps++
	}
	fmt.Println("steps:", steps)
}

Отдельного do while нет. Как получить поведение «выполнить хотя бы один раз», показано на странице о цикле while.

Бесконечные циклы

for без ничего после него крутится вечно. Выйти можно через break, return, os.Exit или панику:

for {
	line, err := reader.ReadString('\n')
	if err != nil {
		break
	}
	process(line)
}

Это стандартная форма для серверов, воркеров и циклов чтения ввода. for {} с пустым телом сжигает ядро процессора; в реальном коде тело блокируется на чём-то (чтение, получение из канала, select).

Циклы range

range обходит коллекцию и на каждой итерации выдаёт одно или два значения. Какие именно, зависит от того, что вы обходите:

Что обходим	Первое значение	Второе значение
слайс или массив	индекс	элемент (копия)
строка	индекс байта	руна (символ Unicode)
мапа	ключ	значение
канал	элемент	(нет)
целое число `n` (Go 1.22)	от 0 до n минус 1	(нет)
функция-итератор (Go 1.23)	то, что отдаёт функция	то, что отдаёт функция

package main

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

func main() {
	nums := []int{10, 20, 30}
	for i, v := range nums {
		fmt.Printf("nums[%d] = %d\n", i, v)
	}

	// only values: discard the index with _
	sum := 0
	for _, v := range nums {
		sum += v
	}
	fmt.Println("sum:", sum)

	// only indexes: omit the second variable
	for i := range nums {
		nums[i] *= 2
	}
	fmt.Println(nums)

	// a string yields runes
	for i, r := range "héllo" {
		fmt.Print(i, ":", string(r), " ")
	}
	fmt.Println()

	// a map yields keys and values in random order, so sort the keys
	ages := map[string]int{"Ben": 25, "Ana": 31, "Chen": 28}
	for _, name := range slices.Sorted(maps.Keys(ages)) {
		fmt.Println(name, ages[name])
	}

	// an integer (Go 1.22)
	for i := range 3 {
		fmt.Print(i, " ")
	}
	fmt.Println()
}

Три детали, которые видны в выводе:

Переменная значения это копия. v *= 2 внутри цикла не изменит слайс; чтобы менять элементы, обращайтесь к слайсу по индексу nums[i], как в третьем цикле.
Индекс строки это смещение в байтах. é занимает два байта, поэтому индекс прыгает с 1 на 3.
Порядок обхода мапы случайный намеренно. Go рандомизирует его, чтобы код не мог от него зависеть. slices.Sorted(maps.Keys(m)) (Go 1.23) даёт ключи по порядку.

range полностью, включая каналы, функции-итераторы и правила копирования, разобран на странице про range.

break и continue

break завершает самый внутренний цикл. continue переходит к следующей итерации (в цикле из трёх частей сначала выполняется post):

package main

import "fmt"

func main() {
	for i := range 10 {
		if i%2 == 0 {
			continue // skip even numbers
		}
		if i > 7 {
			break // stop entirely
		}
		fmt.Print(i, " ")
	}
	fmt.Println()
}

break и continue с меткой

Обычный break выходит только из самого внутреннего цикла. Чтобы выйти из внешнего цикла изнутри вложенного, пометьте внешний цикл:

package main

import "fmt"

func main() {
	grid := [][]int{
		{1, 2, 3},
		{4, 42, 6},
		{7, 8, 9},
	}

	target := 42
	found := false

search:
	for r, row := range grid {
		for c, v := range row {
			if v == target {
				fmt.Printf("found %d at row %d, col %d\n", target, r, c)
				found = true
				break search
			}
		}
	}
	fmt.Println("found:", found)

	// continue with a label skips to the outer loop's next iteration
rows:
	for _, row := range grid {
		for _, v := range row {
			if v%2 == 0 {
				fmt.Println("row with first even number", v)
				continue rows
			}
		}
	}
}

Метка это идентификатор с двоеточием, который ставится прямо перед for. Неиспользуемая метка в Go считается ошибкой компиляции, как и неиспользуемая переменная.

break внутри switch и select

Внутри for оператор break в ветке switch или select выходит из switch или select, а не из цикла:

for {
	switch cmd := next(); cmd {
	case "quit":
		break // only exits the switch; the loop keeps running
	}
}

Чтобы выйти из цикла изнутри switch или select, используйте break с меткой или return.

Переменные цикла начиная с Go 1.22

Go 1.22 изменил область видимости переменных цикла: теперь каждая итерация получает свежую копию i и v. Раньше одна переменная переиспользовалась на весь цикл, что ломало замыкания и горутины, которые её захватывали:

package main

import (
	"fmt"
	"sync"
)

func main() {
	var funcs []func()
	for i := range 3 {
		funcs = append(funcs, func() { fmt.Print(i, " ") })
	}
	for _, f := range funcs {
		f()
	}
	fmt.Println()

	var wg sync.WaitGroup
	results := make([]string, 3)
	for i, name := range []string{"a", "b", "c"} {
		wg.Add(1)
		go func() {
			defer wg.Done()
			results[i] = name + name
		}()
	}
	wg.Wait()
	fmt.Println(results)
}

В Go 1.22 и новее программа печатает 0 1 2 и [aa bb cc]. При старой семантике та же программа, записанная через for i := 0; i < 3; i++ (range по целому числу до 1.22 не существовал), печатала 3 3 3, а горутины устраивали гонку за общие i и name. Старый обходной приём, i := i в начале тела цикла, больше не нужен.

Поведение выбирается для каждого модуля по строке go в go.mod, а не по версии компилятора. Модуль, в котором всё ещё написано go 1.21, сохраняет старую семантику даже при сборке на Go 1.24.

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

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

Добавление элементов во время обхода. range вычисляет слайс один раз, в начале. Элементы, добавленные внутри цикла, не обходятся, так что цикл всё равно завершится, но новых элементов не увидит.

Удаление из слайса по индексу в прямом цикле. Удаление элемента i сдвигает остальные влево, и следующий элемент пропускается. Соберите новый слайс, идите в обратную сторону или используйте slices.DeleteFunc.

Ошибка на единицу с <=. for i := 0; i <= len(s); i++ на последнем проходе читает s[len(s)] и паникует с index out of range. Используйте <, а лучше range.

Тяжёлая работа в условии. Условие выполняется на каждой итерации. for i := 0; i < expensiveCount(); i++ вызывает функцию каждый раз; вычислите значение один раз до цикла.

float в качестве счётчика. for x := 0.0; x != 1.0; x += 0.1 никогда не закончится, потому что у 0.1 нет точного двоичного представления. Считайте целым числом и вычисляйте float из него.

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

Как написать цикл for в Go?

Классическая форма состоит из трёх частей через точку с запятой и пишется без круглых скобок:

for i := 0; i < 5; i++ {
	fmt.Println(i)
}

Начиная с Go 1.22 можно также написать for i := range 5, что считает от 0 до 4. Чтобы пройти по слайсу, используйте for i, v := range items.

Есть ли в Go цикл while?

Ключевого слова while нет, но for с одним только условием и есть цикл while: for n > 0 { n /= 2 }. for { ... } без условия это бесконечный цикл, из которого выходят через break или return.

Как перебрать map в Go?

for key, value := range m { ... }. Порядок обхода не определён, и среда выполнения его рандомизирует, так что он может отличаться от цикла к циклу. Никогда на него не полагайтесь. Для стабильного порядка соберите ключи, отсортируйте их через slices.Sort и пройдите по отсортированным ключам.

Как выйти из вложенного цикла в Go?

Поставьте метку перед внешним циклом и укажите её в break: outer: for ... { for ... { if found { break outer } } }. Обычный break выходит только из самого внутреннего for, switch или select. continue outer аналогично переходит к следующей итерации помеченного цикла.

Что изменилось с переменными цикла в Go 1.22?

До Go 1.22 у цикла for была одна переменная на все итерации, поэтому замыкания и горутины, запущенные в цикле, часто видели последнее значение. Начиная с Go 1.22 каждая итерация получает свою копию, и захват i или v в замыкании работает как ожидается. Новое поведение действует, когда в go.mod модуля указано go 1.22 или новее.

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