Golang if else: Söz Dizimi, Init İfadeleri ve if err != nil

Go'nun if'i koşulun etrafında parantez kullanmaz, her zaman süslü parantez ister ve if'e özel kapsamlı değişkenler tanımlayan kısa bir ifadeyle başlayabilir.

package main

import "fmt"

func grade(score int) string {
	var g string
	if score >= 90 {
		g = "A"
	} else if score >= 80 {
		g = "B"
	} else if score >= 70 {
		g = "C"
	} else {
		g = "F"
	}
	return g
}

func main() {
	for _, s := range []int{95, 83, 70, 42} {
		fmt.Println(s, grade(s))
	}
}

Koşullar yukarıdan aşağı kontrol edilir ve ilk doğru dal çalışır. else if ve else isteğe bağlıdır.

Söz Dizimi Kuralları

Üç kural C, Java ve JavaScript'ten farklıdır:

1. Koşulun etrafında parantez yok. if (x > 5) derlenir, ama gofmt parantezleri kaldırır.
2. Tek bir ifade için bile süslü parantez zorunludur. Süslü parantezsiz bir if x > 5 return yoktur.
3. else kapanış süslü paranteziyle aynı satıra gelir. Go, satır sonundaki bir }'den sonra noktalı virgül ekler, bu yüzden şu başarısız olur:

if x > 5 {
	fmt.Println("big")
}
else {
	fmt.Println("small")
}

syntax error: unexpected keyword else, expected }

} else { ifadesini tek satırda yazın.

Koşul bir bool olmalıdır. Go 0, "" ya da nil'i false olarak görmez, bu yüzden if count {} ve if name {} derlenmez. Açıkça karşılaştırın: if count > 0, if name != "", if user != nil.

Koşulları && (ve), || (veya) ve ! (değil) ile birleştirin. && ve || kısa devre yapar, bu da nil kontrollerini güvenli kılar:

if user != nil && user.IsAdmin() {
	// user.IsAdmin() is only called when user is not nil
}

Init İfadeli if

Bir if, koşuldan önce noktalı virgülle ayrılmış kısa bir ifade çalıştırabilir. İçinde tanımlanan değişkenler o if'in her dalında görünür, sonrasında hiçbir yerde görünmez:

package main

import (
	"fmt"
	"strconv"
)

func main() {
	inputs := []string{"42", "-7", "abc"}

	for _, in := range inputs {
		if n, err := strconv.Atoi(in); err != nil {
			fmt.Printf("%q is not a number\n", in)
		} else if n < 0 {
			fmt.Printf("%d is negative\n", n)
		} else {
			fmt.Printf("%d doubled is %d\n", n, n*2)
		}
		// n and err do not exist here
	}

	stock := map[string]int{"apples": 3}
	if qty, ok := stock["apples"]; ok {
		fmt.Println("apples in stock:", qty)
	}
	if _, ok := stock["pears"]; !ok {
		fmt.Println("no pears")
	}
}

Bu kalıp kısa ömürlü değişkenleri çevreleyen kapsamın dışında tutar. Map aramalarında (v, ok := m[k]), type assertion'larda (s, ok := v.(string)) ve hatalarda sürekli karşınıza çıkar.

Öbür yüzü şu: değere if'ten sonra ihtiyacınız varsa onu önceden tanımlayın. Yaygın bir hata, bir sonucu init ifadesine koyup sonra aşağıda kullanmaya çalışmaktır.

if err != nil Kalıbı

Başarısız olabilecek fonksiyonlar en sona bir error döndürür. Onu hemen kontrol edin, ele alın ya da döndürün ve mutlu yola girinti olmadan devam edin:

package main

import (
	"errors"
	"fmt"
	"strconv"
)

func parseAge(s string) (int, error) {
	n, err := strconv.Atoi(s)
	if err != nil {
		return 0, fmt.Errorf("age %q: %w", s, err)
	}
	if n < 0 || n > 150 {
		return 0, errors.New("age out of range")
	}
	return n, nil
}

func main() {
	for _, s := range []string{"34", "x", "200"} {
		age, err := parseAge(s)
		if err != nil {
			fmt.Println("error:", err)
			continue
		}
		fmt.Println("age:", age)
	}
}

if err != nil { return ... } sonrasında else olmadığına dikkat edin. Go stili hatayı ele alır, döner ve normal akışı sol kenarda bırakır. Hata yönetimi sayfası sarmalamayı ve hata tiplerini kontrol etmeyi anlatıyor.

İç İçe Yapılar Yerine Erken Dönüşler

Derin iç içe if blokları zor okunur. Koşulları tersine çevirip erken dönün; böylece her kontrol bir koruma gibi okunur:

// Nested
func canCheckout(u *User, cart *Cart) bool {
	if u != nil {
		if u.Verified {
			if len(cart.Items) > 0 {
				return true
			}
		}
	}
	return false
}

// Guards
func canCheckout(u *User, cart *Cart) bool {
	if u == nil || !u.Verified {
		return false
	}
	if len(cart.Items) == 0 {
		return false
	}
	return true
}

Go programcıları buna mutlu yolu sola hizalı tutmak der. revive gibi linter'lar, return ile biten bir bloktan sonra gelen else'i işaretler, çünkü o else boşuna girinti ekler.

if/else ve switch

Tek bir değeri birkaç duruma karşı test eden uzun bir else if zinciri, switch olarak daha iyi okunur. İfadesiz bir switch, keyfi koşullardan oluşan bir if/else if zincirinin yerini alır:

switch {
case score >= 90:
	return "A"
case score >= 80:
	return "B"
default:
	return "F"
}

Bir ya da iki dal için if, üç ya da daha fazlası olduğunda switch kullanın.

Ternary Operatörü Yok

Go'da cond ? a : b yoktur. if ile atama yapın:

label := "odd"
if n%2 == 0 {
	label = "even"
}

Ternary operatörü sayfası nedenini açıklıyor ve alternatifleri gösteriyor.

Sık Yapılan Hatalar

• := ile gölgeleme. if x, err := f(); err == nil { ... } yalnızca if için yeni bir x tanımlar. Dıştaki x güncellenmez.
• Koşulda atama. if x = 5 {}, C'deki gibi sessiz bir hata değil, bir derleme hatasıdır (cannot use assignment x = 5 as value). == kullanın.
• Float'ları == ile karşılaştırmak. if total == 0.3, hesaplanmış değerler için başarısız olur. Bir tolerans ile karşılaştırın.
• Yanlış hatayı kontrol etmek. a, err := f() ve b, err := g() sonrasında her if err != nil'in kendi çağrısının hemen ardından geldiğinden emin olun.

if x > 10 {
	fmt.Println("big")
} else if x > 5 {
	fmt.Println("medium")
} else {
	fmt.Println("small")
}