For Loop di Golang: Keempat Bentuknya dengan Contoh

Go hanya punya satu kata kunci perulangan: for. Kata kunci ini punya empat bentuk, dan keempatnya mencakup setiap perulangan yang biasa kamu tulis dengan for, while, do while, atau foreach di bahasa lain.

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

Header loop tidak diapit tanda kurung, dan kurung kurawal selalu wajib.

Loop Tiga Klausa

for init; condition; post {
	// body
}

1. init berjalan sekali sebelum loop. Biasanya berupa deklarasi variabel singkat seperti i := 0, dan variabel itu hanya ada di dalam loop.
2. condition diperiksa sebelum setiap iterasi. Saat bernilai false, loop berakhir.
3. Badan loop dijalankan.
4. post berjalan setelah setiap iterasi, biasanya 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)
}

Di Go, i++ adalah pernyataan, bukan ekspresi, jadi post tidak bisa berisi i++, j--. Pakai assignment paralel sebagai gantinya: i, j = i+1, j-1.

Ketiga klausa itu opsional. for ; i < 10; {} sah, dan gofmt menulisnya ulang menjadi for i < 10 {}, yaitu bentuk berikutnya.

Loop yang Hanya Berisi Kondisi (while ala Go)

Dengan kondisi saja, for berperilaku seperti while di bahasa lain:

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

Tidak ada do while yang terpisah. Halaman while loop menunjukkan cara mendapatkan perilaku "jalankan minimal sekali".

Loop Tak Terbatas

for tanpa apa pun setelahnya akan berputar selamanya. Tinggalkan dengan break, return, os.Exit, atau panic:

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

Ini adalah bentuk standar untuk server, worker, dan loop input. for {} dengan badan kosong menghabiskan satu core CPU; di kode sungguhan, badan loop tertahan menunggu sesuatu (pembacaan, penerimaan dari channel, select).

Loop range

range melakukan iterasi atas sebuah koleksi dan menghasilkan satu atau dua nilai per iterasi. Apa nilainya bergantung pada apa yang di-range:

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

Tiga detail yang ditunjukkan output-nya:

• Variabel nilai adalah salinan. v *= 2 di dalam loop tidak akan mengubah slice; untuk mengubah elemen, akses lewat indeks slice dengan nums[i], seperti yang dilakukan loop ketiga.
• Indeks pada string adalah offset byte. é memakai dua byte, jadi indeksnya melompat dari 1 ke 3.
• Urutan map acak dengan sengaja. Go mengacaknya supaya kode tidak bisa bergantung pada urutan itu. slices.Sorted(maps.Keys(m)) (Go 1.23) memberikan key secara berurutan.

range dibahas lengkap, termasuk channel, fungsi iterator, dan aturan penyalinannya, di halaman range.

break dan continue

break mengakhiri loop yang paling dalam. continue melompat ke iterasi berikutnya (dengan menjalankan post lebih dulu, di loop tiga klausa):

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 dan continue Berlabel

break biasa hanya meninggalkan loop yang paling dalam. Untuk keluar dari loop luar dari dalam loop yang bersarang, beri label pada loop luar:

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

Label adalah identifier yang diikuti titik dua, ditaruh langsung sebelum for. Go melaporkan label yang tidak dipakai sebagai error kompilasi, sama seperti variabel yang tidak dipakai.

break di dalam switch dan select

Di dalam for, break di sebuah case switch atau select meninggalkan switch atau select, bukan loop-nya:

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

Pakai break berlabel, atau return, untuk meninggalkan loop dari dalam switch atau select.

Variabel Loop Sejak Go 1.22

Go 1.22 mengubah scope variabel loop: setiap iterasi sekarang mendapat salinan baru dari i dan v. Sebelumnya, satu variabel dipakai ulang untuk seluruh loop, dan itu merusak closure serta goroutine yang menangkapnya:

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

Dengan Go 1.22 dan sesudahnya, program ini mencetak 0 1 2 dan [aa bb cc]. Dengan semantik lama, program yang sama yang ditulis dengan for i := 0; i < 3; i++ (range atas integer belum ada sebelum 1.22) mencetak 3 3 3, dan goroutine-goroutine-nya berlomba pada i dan name yang dipakai bersama. Solusi lama, i := i di awal badan loop, sudah tidak diperlukan.

Perilakunya dipilih per modul oleh baris go di go.mod, bukan oleh versi compiler. Modul yang masih menulis go 1.21 tetap memakai semantik lama meskipun di-build dengan Go 1.24.

Kesalahan Umum

Mengubah salinannya. for _, v := range items { v.Count++ } mengubah salinan. Pakai items[i].Count++, atau lakukan range atas slice berisi pointer.

Menambahkan elemen sambil melakukan range. range mengevaluasi slice sekali saja, di awal. Elemen yang ditambahkan di dalam loop tidak dikunjungi, jadi loop tetap berakhir, tetapi tidak akan melihat item yang baru.

Menghapus dari slice berdasarkan indeks di loop yang berjalan maju. Menghapus elemen i menggeser sisanya ke kiri, sehingga elemen berikutnya terlewati. Buat slice baru, lakukan loop mundur, atau pakai slices.DeleteFunc.

Off-by-one dengan <=. for i := 0; i <= len(s); i++ membaca s[len(s)] di putaran terakhir dan panic dengan index out of range. Pakai <, atau lebih baik lagi, range.

Pekerjaan berat di dalam kondisi. Kondisi berjalan di setiap iterasi. for i := 0; i < expensiveCount(); i++ memanggil fungsi itu setiap kali; hitung sekali saja sebelum loop.

Memakai float sebagai counter. for x := 0.0; x != 1.0; x += 0.1 tidak pernah berakhir, karena 0.1 tidak punya representasi biner yang eksak. Hitung dengan integer dan hitung float-nya dari integer itu.

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