Çalıştırılabilir Go Dokümanları: for Döngüsü

Q: Go'da for döngüsü nasıl yazılır?

Klasik biçimin noktalı virgüllerle ayrılmış üç parçası vardır ve parantez kullanılmaz: Go 1.22'den beri 0'dan 4'e kadar sayan for i := range 5 da yazabilirsiniz. Bir slice'ı dolaşmak için for i, v := range items kullanın.

Q: Go'da while döngüsü var mı?

while anahtar kelimesi yok, ama yalnızca koşulu olan bir for bir while döngüsüdür: for n > 0 { n /= 2 }. Koşulsuz for { ... } ise break ya da return ile çıktığınız sonsuz bir döngüdür.

Q: Go'da bir map üzerinde nasıl döngü kurulur?

for key, value := range m { ... }. Dolaşma sırası belirtilmemiştir ve çalışma zamanı onu rastgele hale getirir, bu yüzden bir döngüden diğerine değişebilir. Ona asla güvenmeyin. Kararlı bir sıra için anahtarları toplayın, slices.Sort ile sıralayın ve sıralanmış anahtarlar üzerinde dönün.

Q: Go'da iç içe bir döngüden nasıl çıkılır?

Dış döngünün önüne bir etiket koyun ve break'te onu belirtin: outer: for ... { for ... { if found { break outer } } }. Düz bir break yalnızca en içteki for, switch ya da select'ten çıkar. continue outer da aynı şekilde etiketli döngünün bir sonraki yinelemesine atlar.

Q: Go 1.22'de döngü değişkenleriyle ilgili ne değişti?

Go 1.22'den önce bir for döngüsünün tüm yinelemelerce paylaşılan tek bir değişkeni vardı, bu yüzden döngüde başlatılan closure'lar ve goroutine'ler çoğu zaman hep son değeri görüyordu. Go 1.22'den beri her yineleme kendi kopyasını alır, bu yüzden i ya da v'yi bir closure içinde yakalamak beklendiği gibi çalışır. Yeni davranış, modülün go.mod dosyası go 1.22 ya da sonrasını belirttiğinde geçerlidir.

Go'nun tam olarak bir döngü anahtar kelimesi vardır: for. Dört biçimi vardır ve bunlar birlikte, başka dillerde for, while, do while ya da foreach ile yazacağınız her döngüyü karşılar.

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

Döngü başlığının etrafına parantez konmaz ve süslü parantezler her zaman zorunludur.

Üç Parçalı Döngü

for init; condition; post {
	// body
}

init döngüden önce bir kez çalışır. Genellikle i := 0 gibi kısa bir değişken tanımıdır ve o değişken yalnızca döngünün içinde vardır.
condition her yinelemeden önce kontrol edilir. False olduğunda döngü biter.
Gövde çalışır.
post her yinelemeden sonra çalışır, genellikle 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)
}

i++ Go'da bir ifade (expression) değil, bir deyimdir (statement), bu yüzden post içinde i++, j-- olamaz. Bunun yerine paralel atama kullanın: i, j = i+1, j-1.

Üç parçanın hepsi isteğe bağlıdır. for ; i < 10; {} geçerlidir ve gofmt onu bir sonraki biçim olan for i < 10 {}'ye çevirir.

Yalnızca Koşullu Döngü (Go'nun while'ı)

Yalnızca bir koşulla for, başka dillerdeki while gibi davranır:

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

Ayrı bir do while yoktur. While döngüsü sayfası "en az bir kez çalış" davranışının nasıl elde edileceğini gösteriyor.

Sonsuz Döngüler

Arkasında hiçbir şey olmayan for sonsuza kadar döner. Ondan break, return, os.Exit ya da bir panic ile çıkın:

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

Bu, sunucular, worker'lar ve girdi döngüleri için standart biçimdir. Gövdesi boş bir for {} bir CPU çekirdeğini boşuna yakar; gerçek kodda gövde bir şey üzerinde bloklanır (bir okuma, bir channel alımı, bir select).

range Döngüleri

range bir koleksiyon üzerinde döner ve her yinelemede bir ya da iki değer verir. Bunların ne olduğu neyin üzerinde döndüğünüze bağlıdır:

Üzerinde dönülen	İlk değer	İkinci değer
slice ya da dizi	indeks	eleman (bir kopya)
string	bayt indeksi	rune (Unicode karakteri)
map	anahtar	değer
channel	eleman	(yok)
tam sayı `n` (Go 1.22)	0'dan n eksi 1'e	(yok)
iterator fonksiyonu (Go 1.23)	fonksiyonun verdiği	fonksiyonun verdiği

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

Çıktının gösterdiği üç ayrıntı:

Değer değişkeni bir kopyadır. Döngü içindeki v *= 2 slice'ı değiştirmez; elemanları değiştirmek için üçüncü döngünün yaptığı gibi nums[i] ile slice'a indeksleyin.
Bir string'in indeksi bir bayt konumudur. é iki bayt tutar, bu yüzden indeks 1'den 3'e atlar.
Map sırası bilerek rastgeledir. Go, kod ona bağımlı olamasın diye sırayı rastgele hale getirir. slices.Sorted(maps.Keys(m)) (Go 1.23) anahtarları sıralı verir.

range; channel'lar, iterator fonksiyonları ve kopyalama kuralları dahil tüm ayrıntılarıyla range sayfasında anlatılıyor.

break ve continue

break en içteki döngüyü sonlandırır. continue bir sonraki yinelemeye atlar (üç parçalı döngüde önce post çalışır):

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

Etiketli break ve continue

Düz bir break yalnızca en içteki döngüden çıkar. İç içe bir döngünün içinden dış döngüden çıkmak için dış döngüyü etiketleyin:

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

Etiket, ardından iki nokta gelen bir tanımlayıcıdır ve doğrudan for'un önüne konur. Go, kullanılmayan bir etiketi, tıpkı kullanılmayan bir değişken gibi derleme hatası olarak raporlar.

switch ve select içinde break

Bir for içinde, bir switch ya da select case'indeki break döngüden değil, switch ya da select'ten çıkar:

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

Bir switch ya da select içinden döngüden çıkmak için etiketli bir break ya da return kullanın.

Go 1.22'den Beri Döngü Değişkenleri

Go 1.22 döngü değişkenlerinin kapsamını değiştirdi: her yineleme artık i ve v'nin yeni bir kopyasını alıyor. Önceden tüm döngü boyunca tek bir değişken yeniden kullanılıyordu ve bu, onu yakalayan closure'ları ve goroutine'leri bozuyordu:

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 ve sonrasında bu program 0 1 2 ve [aa bb cc] yazdırır. Eski semantikte for i := 0; i < 3; i++ ile yazılmış aynı program (tam sayı üzerinde range 1.22'den önce yoktu) 3 3 3 yazdırıyordu ve goroutine'ler paylaşılan i ve name üzerinde race'e giriyordu. Eski geçici çözüm olan, döngü gövdesinin başındaki i := i artık gerekmez.

Davranış, derleyici sürümüne göre değil, go.mod içindeki go satırına göre modül başına belirlenir. Hâlâ go 1.21 diyen bir modül, Go 1.24 ile derlense bile eski semantiği korur.

Sık Yapılan Hatalar

Kopyayı değiştirmek. for _, v := range items { v.Count++ } bir kopyayı değiştirir. items[i].Count++ kullanın ya da pointer'lardan oluşan bir slice üzerinde dönün.

Dönerken eleman eklemek. range slice'ı başta bir kez değerlendirir. Döngü içinde eklenen elemanlar ziyaret edilmez; döngü yine sonlanır ama yeni öğeleri görmez.

İleri doğru giden bir döngüde indeksle slice'tan silmek. i elemanını silmek geri kalanı sola kaydırır, bu yüzden bir sonraki eleman atlanır. Yeni bir slice oluşturun, geriye doğru dönün ya da slices.DeleteFunc kullanın.

<= ile bir fazla hatası. for i := 0; i <= len(s); i++ son turda s[len(s)]'i okur ve index out of range ile panic olur. < kullanın, daha iyisi range.

Koşulda ağır iş. Koşul her yinelemede çalışır. for i := 0; i < expensiveCount(); i++ fonksiyonu her seferinde çağırır; onu döngüden önce bir kez hesaplayın.

Sayaç olarak float kullanmak. for x := 0.0; x != 1.0; x += 0.1 hiç bitmez, çünkü 0.1'in kesin bir ikili temsili yoktur. Bir tam sayıyla sayın ve float'ı ondan hesaplayın.

Sıkça Sorulan Sorular

Go'da for döngüsü nasıl yazılır?

Klasik biçimin noktalı virgüllerle ayrılmış üç parçası vardır ve parantez kullanılmaz:

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

Go 1.22'den beri 0'dan 4'e kadar sayan for i := range 5 da yazabilirsiniz. Bir slice'ı dolaşmak için for i, v := range items kullanın.

Go'da while döngüsü var mı?

while anahtar kelimesi yok, ama yalnızca koşulu olan bir for bir while döngüsüdür: for n > 0 { n /= 2 }. Koşulsuz for { ... } ise break ya da return ile çıktığınız sonsuz bir döngüdür.

Go'da bir map üzerinde nasıl döngü kurulur?

for key, value := range m { ... }. Dolaşma sırası belirtilmemiştir ve çalışma zamanı onu rastgele hale getirir, bu yüzden bir döngüden diğerine değişebilir. Ona asla güvenmeyin. Kararlı bir sıra için anahtarları toplayın, slices.Sort ile sıralayın ve sıralanmış anahtarlar üzerinde dönün.

Go'da iç içe bir döngüden nasıl çıkılır?

Dış döngünün önüne bir etiket koyun ve break'te onu belirtin: outer: for ... { for ... { if found { break outer } } }. Düz bir break yalnızca en içteki for, switch ya da select'ten çıkar. continue outer da aynı şekilde etiketli döngünün bir sonraki yinelemesine atlar.

Go 1.22'de döngü değişkenleriyle ilgili ne değişti?

Go 1.22'den önce bir for döngüsünün tüm yinelemelerce paylaşılan tek bir değişkeni vardı, bu yüzden döngüde başlatılan closure'lar ve goroutine'ler çoğu zaman hep son değeri görüyordu. Go 1.22'den beri her yineleme kendi kopyasını alır, bu yüzden i ya da v'yi bir closure içinde yakalamak beklendiği gibi çalışır. Yeni davranış, modülün go.mod dosyası go 1.22 ya da sonrasını belirttiğinde geçerlidir.

İlgili kavramlar