range di Golang: Semua Bentuknya, Hasilnya, dan Jebakannya

range adalah bentuk for yang menelusuri sebuah koleksi. Ia memberimu satu atau dua nilai per iterasi, dan nilai apa yang diberikan bergantung pada tipe yang kamu telusuri:

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

Memilih variabel yang kamu dapat

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

Mendeklarasikan variabel yang tidak dipakai adalah compile error, jadi hilangkan atau ganti dengan blank identifier variabel yang tidak kamu butuhkan. for range 3 {} adalah cara terpendek untuk mengulang sesuatu tiga kali.

Nilainya adalah salinan

Di setiap iterasi, elemen disalin ke variabel nilai. Mengubah variabel itu tidak mengubah koleksinya:

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

Menyalin juga memakan waktu saat elemennya berupa struct besar. Untuk slice berisi struct besar, for i := range s dengan s[i] menghindari penyalinan itu.

String menghasilkan rune

Melakukan range pada string akan men-decode UTF-8. Nilai pertamanya adalah offset byte tempat setiap karakter dimulai, jadi angkanya bisa melompat:

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

Untuk menelusuri byte alih-alih karakter, pakai loop dengan indeks, for i := 0; i < len(s); i++, atau lakukan range pada []byte(s). Lihat halaman rune dan byte untuk detail UTF-8.

Map: urutan acak

Urutan iterasi map tidak ditentukan, dan runtime mengacaknya supaya kode tidak bisa bergantung pada satu urutan. Untuk output yang deterministik, urutkan key-nya:

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

Menghapus entri selama range itu aman, dan entri terhapus yang belum dicapai tidak akan dihasilkan. Menambah entri diperbolehkan tapi tidak bisa diprediksi: key baru mungkin muncul belakangan di perulangan yang sama, mungkin juga tidak. fmt.Println pada map mencetak key secara terurut, itulah sebabnya baris terakhir selalu stabil.

Channel: sampai ditutup

Melakukan range pada channel menerima nilai sampai channel itu ditutup dan dikosongkan. Kalau tidak ada yang menutupnya, perulangan terblokir selamanya (dan kalau setiap goroutine terblokir, runtime berhenti dengan 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()
}

Yang menutup channel adalah pengirimnya, tidak pernah penerimanya. Lihat halaman channel untuk buffered channel dan select.

Integer (Go 1.22)

range n menghitung naik dari 0 dan berhenti tepat sebelum n. Tipe variabel loop-nya sama dengan tipe 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 yang negatif juga berjalan nol kali. n dievaluasi satu kali, sebelum perulangan dimulai.

Apa yang dievaluasi range, dan kapan

Ekspresi setelah range dievaluasi satu kali, sebelum iterasi pertama. Untuk slice, range lalu memakai header slice itu, jadi panjangnya tetap:

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 yang ditambahkan tidak pernah dikunjungi karena panjang perulangannya sudah ditetapkan 3. Tapi nums[2] = 30 terlihat, karena saat itu nums masih berbagi backing array dengan slice yang sedang ditelusuri. Tukar kedua baris itu dan 30 juga ikut hilang: append melebihi kapasitas 3, mengalokasikan array baru, dan penulisannya justru terjadi di sana. Melakukan range pada nilai array menyalin seluruh array lebih dulu, jadi perubahan pada arr[2] tidak terlihat; lakukan range pada &arr atau arr[:] untuk menghindari penyalinan.

Range pada fungsi (Go 1.23)

Sejak Go 1.23, range juga menerima fungsi iterator. Iterator menerima callback yield, memanggilnya sekali untuk setiap nilai, dan berhenti saat yield mengembalikan false (yang terjadi saat badan perulangan menjalankan break atau 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] dan iter.Seq2[K, V] adalah nama standar untuk kedua bentuk iterator. Standard library mengembalikannya dari slices.All, slices.Values, slices.Backward, maps.Keys, maps.Values, maps.All, dan di Go 1.24 dari strings.SplitSeq, strings.Lines, dan bytes.SplitSeq. Iterator harus menghormati nilai kembalian yield: memanggil yield lagi setelah ia mengembalikan false akan memicu panic.

Variabel loop berbeda di setiap iterasi (Go 1.22)

Sejak Go 1.22, variabel yang dideklarasikan oleh for ... range selalu baru di setiap iterasi. Menangkap v di closure atau goroutine berarti menangkap nilai iterasi itu, bukan variabel bersama yang akhirnya berisi elemen terakhir. Sebelum Go 1.22, kamu butuh v := v di dalam perulangan; baris itu kini tidak diperlukan lagi. Aturan ini ditentukan oleh versi go di go.mod, jadi module lama tetap memakai perilaku lama.

Kesalahan umum

• Mengambil alamat variabel nilai. Sebelum Go 1.22, ptrs = append(ptrs, &v) menyimpan alamat yang sama setiap kali. Sejak 1.22, alamat yang disimpan berbeda-beda, tapi masing-masing menunjuk ke salinan, bukan ke elemen slice. Pakai &items[i] untuk menunjuk ke dalam slice.
• Mengharapkan urutan map. Output yang terlihat terurut di test kecil tidak akan tetap terurut.
• Melakukan range pada channel yang tidak pernah ditutup. Perulangan itu, dan goroutine yang menjalankannya, menunggu selamanya.
• Melakukan range pada array besar sebagai nilai. Seluruh array disalin lebih dulu. Lakukan range pada slice dari array itu sebagai gantinya.