Golang While Döngüsü: Go'da while ve do-while Nasıl Yazılır

Go'da while anahtar kelimesi yoktur. for ardından bir koşul yazın, bir while döngünüz olur:

package main

import "fmt"

func main() {
	balance := 1000.0
	years := 0

	for balance < 2000 {
		balance *= 1.07
		years++
	}

	fmt.Printf("doubled after %d years: %.2f\n", years, balance)
}

Koşul her yinelemeden önce kontrol edilir, bu yüzden başta false ise gövde hiç çalışmaz. Bu, parantezler ve anahtar kelime dışında C, Java ya da JavaScript'teki while (balance < 2000) ile aynıdır. Go'nun tasarımcıları her döngü biçimi için tek bir döngü anahtar kelimesi seçti; dört biçimin hepsi için for döngüsü sayfasına bakın.

while(true): Sonsuz Döngü

Koşulu tamamen yazmazsanız döngü, içindeki bir şey onu bitirene kadar çalışır:

package main

import "fmt"

func main() {
	queue := []string{"email", "resize", "stop", "never-reached"}

	for {
		job := queue[0]
		queue = queue[1:]

		if job == "stop" {
			fmt.Println("stopping")
			break
		}
		fmt.Println("processing", job)
	}

	fmt.Println("left in queue:", queue)
}

Deyimsel yazım for { }'dir. for true { } da derlenir, ama yazarı başka bir dilden gelmiş gibi okunur.

Sonsuz bir döngüyü dört şey bitirir: break (döngüden çıkar), return (fonksiyondan çıkar), bir panic ve os.Exit. main fonksiyonu bunların hiçbiri olmadan for {} içinde duran bir program, öldürülene kadar çalışır; bu da bir sunucu ya da worker için tam olarak doğru davranıştır.

do-while

Bir do-while, koşulu kontrol etmeden önce gövdeyi bir kez çalıştırır. Go'da buna özel bir söz dizimi yoktur. Kontrolü sonsuz bir döngünün sonuna koyun:

package main

import (
	"fmt"
	"math/rand/v2"
)

func main() {
	r := rand.New(rand.NewPCG(8, 8))

	rolls := 0
	for {
		roll := r.IntN(6) + 1
		rolls++
		fmt.Println("rolled", roll)

		if roll == 6 {
			break
		}
	}
	fmt.Println("needed", rolls, "rolls to get a 6")
}

Gövde ne olursa olsun en az bir kez çalışır; do-while'ı tanımlayan özellik budur. Rastgele kaynak sabit bir seed kullanır, bu yüzden çıktı her çalıştırmada aynıdır; gerçek rastgelelik için seed verilmiş bir kaynak olmadan rand.IntN kullanın.

İkinci bir biçim, ilk turu zorlayarak koşulu başlıkta tutar:

for first := true; first || condition(); first = false {
	// body
}

Çalışır, ama sonunda break olan sonsuz döngü daha kolay okunur ve Go kodunun çoğu da bunu yapar.

Bitene Kadar Okumak

Gerçek Go kodundaki en yaygın while döngüsü, girdi bitene kadar okur. bufio.Scanner bunun için tasarlanmıştır: Scan, girdinin sonunda ya da bir hatada false döndürür, bu yüzden döngü koşuludur:

package main

import (
	"bufio"
	"fmt"
	"strings"
)

func main() {
	input := "first line\nsecond line\nthird line\n"
	scanner := bufio.NewScanner(strings.NewReader(input))

	n := 0
	for scanner.Scan() {
		n++
		fmt.Printf("%d: %s\n", n, scanner.Text())
	}
	if err := scanner.Err(); err != nil {
		fmt.Println("read error:", err)
	}
}

strings.NewReader(input) yerine os.Stdin koyun, aynı döngü kullanıcının girdisini satır satır okur. Döngüden sonra scanner.Err()'ü kontrol edin: Scan'in false döndürmesi, girdinin normal biçimde mi bittiğini yoksa başarısız mı olduğunu söylemez.

break ve continue

İkisi de for'un her biçiminde çalışır:

package main

import "fmt"

func main() {
	n := 0
	for n < 20 {
		n++
		if n%3 != 0 {
			continue // back to the condition check
		}
		if n > 12 {
			break
		}
		fmt.Print(n, " ")
	}
	fmt.Println()
}

Yalnızca koşullu bir döngüde continue doğrudan koşula atlar. Bu, ince bir hatayı kolaylaştırır: sayaç gövdenin altında güncelleniyorsa, onun üstündeki bir continue güncellemeyi atlar ve döngü hiç bitmez. Sayacı yukarıdaki gibi en üstte güncelleyin ya da post ifadesi continue'dan sonra bile çalışan üç parçalı bir for kullanın.

Bir Şeyi Beklemek

Bir koşulu bekleyen döngü boşa dönmemeli, bloklanmalı ya da uyumalıdır:

// Wrong: burns a CPU core while waiting
for !ready {
}

// Better: poll with a delay
for !isReady() {
	time.Sleep(100 * time.Millisecond)
}

Başka bir goroutine'in yazdığı düz bir değişkeni yoklamak aynı zamanda bir data race'tir. Goroutine'ler arasında bunun yerine bir channel, bir sync.WaitGroup ya da bir sync.Cond üzerinde bekleyin veya bir timer ile select kullanın. Sınırlı yeniden deneme döngüleri için, döngü sonsuza kadar çalışamasın diye sayaçlı bir for tercih edin:

for attempt := 1; attempt <= 5; attempt++ {
	if err := connect(); err == nil {
		break
	}
	time.Sleep(time.Duration(attempt) * 200 * time.Millisecond)
}

Sık Yapılan Hatalar

• Koşul değişkenini değiştirmeyi unutmak. for i < 10 { fmt.Println(i) } hiç bitmez. Her while döngüsünün gövdesinde onu çıkışa doğru ilerleten bir şey olmalıdır.
• while yazmak. while x < 5 {}, syntax error: unexpected name x at end of statement verir, çünkü while bir anahtar kelime değildir; derleyici onu sıradan bir ad olarak okur.
• Alışkanlıktan parantez. for (x < 5) {} derlenir ve gofmt parantezleri kaldırır.
• Değişkeni döngüde tanımlamak. for n := 10; n > 0 {} bir söz dizimi hatasıdır; init parçası olan bir döngü üç parçanın hepsini ister. n'i döngüden önce tanımlayın ya da tam üç parçalı biçimi yazın.

for count < 10 {
	count++
}

for {
	// body runs at least once
	if !condition {
		break
	}
}