Range w Golang: wszystkie formy, co zwraca i gdzie są pułapki

range to forma for, która przechodzi po kolekcji. Daje jedną lub dwie wartości na iterację, a to, czym są te wartości, zależy od typu, po którym iterujesz:

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

Wybór zmiennych, które dostajesz

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

Zadeklarowanie nieużywanej zmiennej to błąd kompilacji, więc pomiń albo zastąp przez _ te, których nie potrzebujesz. for range 3 {} to najkrótszy sposób, żeby coś powtórzyć trzy razy.

Wartość jest kopią

W każdej iteracji element jest kopiowany do zmiennej wartości. Zmiana zmiennej nie zmienia kolekcji:

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

Kopiowanie kosztuje też czas, gdy elementy są dużymi strukturami. Dla slice'a dużych struktur for i := range s z s[i] pozwala uniknąć kopii.

Stringi zwracają runy

Range po stringu dekoduje UTF-8. Pierwsza wartość to przesunięcie w bajtach, od którego zaczyna się każdy znak, więc może przeskakiwać liczby:

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

Aby przejść po bajtach zamiast po znakach, użyj pętli z indeksem, for i := 0; i < len(s); i++, albo range po []byte(s). Szczegóły UTF-8 opisuje strona o runach i bajtach.

Mapy: losowa kolejność

Kolejność iteracji po mapie nie jest określona, a runtime ją losuje, żeby kod nie mógł zacząć zależeć od jednej kolejności. Dla deterministycznego wyniku posortuj klucze:

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

Usuwanie wpisów w trakcie range jest bezpieczne, a usunięty wpis, do którego pętla jeszcze nie dotarła, nie zostanie zwrócony. Dodawanie wpisów jest dozwolone, ale nieprzewidywalne: nowy klucz może pojawić się później w tej samej pętli albo nie. fmt.Println wypisuje mapę z posortowanymi kluczami, dlatego ostatnia linia jest stabilna.

Kanały: do zamknięcia

Range po kanale odbiera wartości, dopóki kanał nie zostanie zamknięty i opróżniony. Jeśli nikt go nie zamknie, pętla blokuje się na zawsze (a jeśli wszystkie gorutyny są zablokowane, runtime zatrzymuje się z 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()
}

Kanał zamyka nadawca, nigdy odbiorca. Kanały buforowane i select opisuje strona o kanałach.

Liczby całkowite (Go 1.22)

range n liczy od 0 do n, ale bez n. Typ zmiennej pętli to typ 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

Ujemne n również wykonuje się zero razy. n jest obliczane raz, przed startem pętli.

Co range oblicza i kiedy

Wyrażenie po range jest obliczane raz, przed pierwszą iteracją. Dla slice'a range używa potem tego nagłówka slice'a, więc jego długość jest stała:

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

Dołączone 99 nigdy nie zostaje odwiedzone, bo długość pętli ustalono na 3. Ale nums[2] = 30 jest widoczne, bo w tym momencie nums nadal współdzieli tablicę bazową ze slice'em, po którym iteruje pętla. Zamień te dwie linie miejscami, a 30 też zniknie: append przekracza pojemność 3, alokuje nową tablicę i zapis trafia właśnie tam. Range po wartości tablicy najpierw kopiuje całą tablicę, więc zmiana arr[2] nie jest widoczna; iteruj po &arr albo arr[:], żeby uniknąć kopii.

Range po funkcjach (Go 1.23)

Od Go 1.23 range przyjmuje też funkcje iteratorów. Iterator przyjmuje callback yield, wywołuje go raz na każdą wartość i kończy, gdy yield zwróci false (co dzieje się, gdy ciało pętli wykona break albo 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] i iter.Seq2[K, V] to standardowe nazwy dwóch kształtów iteratorów. Biblioteka standardowa zwraca je z slices.All, slices.Values, slices.Backward, maps.Keys, maps.Values, maps.All, a w Go 1.24 także z strings.SplitSeq, strings.Lines i bytes.SplitSeq. Iterator musi respektować wartość zwracaną przez yield: ponowne wywołanie yield po tym, jak zwróciło false, wywołuje panikę.

Zmienne pętli są osobne dla każdej iteracji (Go 1.22)

Od Go 1.22 zmienne deklarowane przez for ... range są nowe w każdej iteracji. Przechwycenie v w domknięciu lub gorutynie przechwytuje wartość z tej iteracji, a nie wspólną zmienną, która na końcu trzyma ostatni element. Przed Go 1.22 potrzebne było v := v wewnątrz pętli; teraz ta linia jest zbędna. Regułę ustala wersja go w go.mod, więc stary moduł zachowuje stare zachowanie.

Częste błędy

• Pobieranie adresu zmiennej wartości. Przed Go 1.22 ptrs = append(ptrs, &v) za każdym razem zapisywało ten sam adres. Od 1.22 zapisuje różne adresy, ale każdy wskazuje na kopię, a nie na element slice'a. Użyj &items[i], żeby wskazywać do wnętrza slice'a.
• Oczekiwanie kolejności w mapie. Wynik, który w małym teście wygląda na posortowany, nie pozostanie posortowany.
• Range po kanale, którego nikt nie zamyka. Pętla i gorutyna, która ją wykonuje, czekają w nieskończoność.
• Range po dużej tablicy przez wartość. Najpierw kopiowana jest cała tablica. Zamiast tego iteruj po jej slice'ie.