Koşullar, döngüler ve switch

Bir hava durumu uygulaması sıcaklığa bakıp “sıcak” ya da “soğuk” yazar; bir oyun ise oyuncu kazanana kadar aynı adımları tekrarlar. Programın karar vermesi ve işleri tekrarlaması için koşullar ve döngüler gerekir. Go'da bunun için yalnızca üç araç vardır: if, for ve switch. Her biri basit olduğu kadar güçlüdür.

if, else ve başlangıç ifadesi

Go'da koşul paranteze alınmaz, ama süslü parantezler tek satırlık bir blokta bile zorunludur. else if ile istediğin kadar koşul denetleyebilirsin. Özel bir imkân: koşuldan önce bir başlangıç ifadesi ve noktalı virgül yazılabilir, örneğin if n, err := strconv.Atoi(s); err == nil. Orada oluşturulan değişkenler yalnızca if ve else bloklarının içinde görünür.

package main

import (
	"fmt"
	"strconv"
)

func main() {
	temperature := 28
	if temperature > 30 {
		fmt.Println("Hot")
	} else if temperature > 20 {
		fmt.Println("Warm")
	} else {
		fmt.Println("Cold")
	}

	if n, err := strconv.Atoi("17"); err == nil {
		fmt.Println("double:", n*2)
	}
	if _, err := strconv.Atoi("abc"); err != nil {
		fmt.Println("error:", err)
	}
}

Warm
double: 34
error: strconv.Atoi: parsing "abc": invalid syntax

Koşullarda karşılaştırma operatörleri (==, !=, <, >, <=, >=) ve mantıksal operatörler kullanılır: && (ve), || (veya), ! (değil). Go'da koşul mutlaka bir bool olmalıdır: C'deki gibi if n yazılamaz, if n != 0 yazmak gerekir.

for — tek döngü

Go'da while ve do-while yoktur: bütün döngüler for ile yazılır. Ancak for'un birkaç biçimi vardır ve diğer dillerdeki tüm döngülerin yerini tutar. break döngüyü durdurur, continue ise o adımın geri kalanını atlayıp bir sonrakine geçer.

package main

import "fmt"

func main() {
	for i := 1; i <= 3; i++ {
		fmt.Println("step", i)
	}

	n := 1
	for n < 100 {
		n *= 3
	}
	fmt.Println("n =", n)

	for i := range 5 {
		if i%2 == 0 {
			continue
		}
		fmt.Println("odd:", i)
	}

	for i, r := range "Gəncə" {
		fmt.Println(i, string(r))
	}
}

step 1
step 2
step 3
n = 243
odd: 1
odd: 3
0 G
1 ə
3 n
4 c
5 ə

Yalnızca koşullu döngü, n 100'ü geçene kadar onu 3 ile çarpar: 1 → 3 → 9 → 27 → 81 → 243. Şimdi son döngüye bak: range bir dizede baytlarla değil, karakterlerle (rune'larla) ilerler; i ise karakterin başladığı baytın indeksidir. ə iki bayt yer kapladığı için indeks 1'den doğrudan 3'e atlar. İndekse ihtiyacın yoksa yerine _ yaz: for _, r := range s.

switch

switch bir değeri birkaç seçenekle karşılaştırır. Java ve C'den farklı olarak Go'da her case'in sonuna break yazmak gerekmez: eşleşen blok çalışır ve switch biter. Bir case'te virgülle ayrılmış birkaç değer sıralanabilir. İfadesiz bir switch ise uzun bir if-else zincirinin yerini alır: her case kendi koşulunu taşır.

package main

import "fmt"

func main() {
	day := "Saturday"
	switch day {
	case "Saturday", "Sunday":
		fmt.Println("Weekend")
	default:
		fmt.Println("Weekday")
	}

	score := 83
	switch {
	case score >= 90:
		fmt.Println("Excellent")
	case score >= 75:
		fmt.Println("Good")
	default:
		fmt.Println("Keep going")
	}

	switch n := 2; n {
	case 2:
		fmt.Println("two")
		fallthrough
	case 3:
		fmt.Println("three")
	case 4:
		fmt.Println("four")
	}
}

Weekend
Good
two
three

if gibi switch de bir başlangıç ifadesi alabilir: switch n := 2; n. fallthrough anahtar kelimesi ise koşulunu denetlemeden bir sonraki case'in bloğunu da çalıştırır; bu yüzden örnekte two'dan sonra three de yazıldı. Gerçek kodda buna çok nadiren ihtiyaç duyulur.

if score >= 90 {
	grade = "A"
} else if score >= 75 {
	grade = "B"
} else if score >= 50 {
	grade = "C"
} else {
	grade = "F"
}

switch {
case score >= 90:
	grade = "A"
case score >= 75:
	grade = "B"
case score >= 50:
	grade = "C"
default:
	grade = "F"
}

package main

import "fmt"

func main() {
	commands := []string{"move", "jump", "stop", "move"}
loop:
	for _, c := range commands {
		switch c {
		case "stop":
			break loop
		default:
			fmt.Println("doing", c)
		}
	}
	fmt.Println("finished")
}

doing move
doing jump
finished