Golang switch case: fallthrough ve Birden Fazla Değer

Bir switch, bir değeri case listesiyle karşılaştırır ve ilk eşleşeni çalıştırır. C, Java ve JavaScript'ten farklı olarak Go'da bir case bir sonrakine geçmez, bu yüzden unutulacak bir break yoktur.

package main

import "fmt"

func describe(day string) string {
	switch day {
	case "sat", "sun":
		return "weekend"
	case "fri":
		return "almost weekend"
	case "mon", "tue", "wed", "thu":
		return "weekday"
	default:
		return "not a day"
	}
}

func main() {
	for _, d := range []string{"sun", "fri", "tue", "xyz"} {
		fmt.Println(d, "->", describe(d))
	}
}

Case'ler yukarıdan aşağı kontrol edilir ve yalnızca ilk eşleşen case çalışır. Hiçbir şey eşleşmediğinde default çalışır; isteğe bağlıdır ve listenin herhangi bir yerinde olabilir, ama geleneksel olarak en sona konur.

Case Başına Birden Fazla Değer

case "sat", "sun": iki değerden birine eşleşir. Go, C'nin üst üste dizilmiş boş case'lerle yaptığını böyle ifade eder. Karşılaştırılabilir her tip çalışır: string'ler, sayılar, rune'lar, boolean'lar, pointer'lar ve enum'lar gibi adlandırılmış tipler:

package main

import "fmt"

func kind(r rune) string {
	switch r {
	case 'a', 'e', 'i', 'o', 'u':
		return "vowel"
	case ' ', '\t', '\n':
		return "space"
	default:
		return "other"
	}
}

func main() {
	for _, r := range "go on" {
		fmt.Printf("%q %s\n", r, kind(r))
	}
}

Aynı sabit değere sahip iki case derleme hatasıdır:

./main.go:10:7: duplicate case 1 (constant of type int) in expression switch
	./main.go:8:7: previous case

Koşulsuz switch

İfadeyi yazmazsanız her case bir boolean teste dönüşür. Bu, uzun bir if/else if zincirinin Go'daki daha temiz biçimidir:

package main

import "fmt"

func bmiCategory(bmi float64) string {
	switch {
	case bmi < 18.5:
		return "underweight"
	case bmi < 25:
		return "normal"
	case bmi < 30:
		return "overweight"
	default:
		return "obese"
	}
}

func main() {
	for _, b := range []float64{17.2, 22.0, 27.9, 31.5} {
		fmt.Printf("%.1f %s\n", b, bmiCategory(b))
	}
}

switch {, switch true { ifadesinin kısaltmasıdır. İlk doğru case kazandığı için sıra önemlidir: bmi < 25'e yalnızca bmi < 18.5 false olduğunda ulaşılır, bu yüzden her case yukarıdakilerin başarısız olduğunu varsayabilir.

Init İfadeli switch

if gibi bir switch de kısa bir ifadeyle başlayabilir. Orada tanımlanan değişkenlerin kapsamı switch ile sınırlıdır:

package main

import (
	"fmt"
	"strings"
)

func main() {
	inputs := []string{"  YES ", "no", "maybe"}

	for _, in := range inputs {
		switch answer := strings.ToLower(strings.TrimSpace(in)); answer {
		case "y", "yes":
			fmt.Println("confirmed")
		case "n", "no":
			fmt.Println("declined")
		default:
			fmt.Printf("unknown answer %q\n", answer)
		}
	}
}

Init ifadesi koşulsuz bir switch ile de birleştirilebilir: switch n := len(items); { case n == 0: ... }.

fallthrough

Gerçekten bir sonraki case'e devam etmek istediğinizde, bir case'in son ifadesi olarak fallthrough yazın. Kontrolü bir sonraki case'in gövdesine koşulunu değerlendirmeden aktarır:

package main

import "fmt"

func main() {
	level := 2

	fmt.Println("permissions for level", level)
	switch level {
	case 3:
		fmt.Println("  delete")
		fallthrough
	case 2:
		fmt.Println("  write")
		fallthrough
	case 1:
		fmt.Println("  read")
	}
}

Seviye 2 önce write, sonra read yazdırır ve izinleri aşağı doğru biriktirir. Sonraki case'lerin koşulları kontrol edilmez: case 2'den gelen fallthrough sonrasında, level 2 olmasına rağmen case 1 çalışır.

fallthrough kuralları:

• Case'teki son ifade olmalıdır.
• Son case'te bulunamaz: cannot fallthrough final case in switch.
• Bir type switch içinde izin verilmez.

Pratikte Go kodunda fallthrough nadirdir. Case başına birden fazla değer yaygın ihtiyacı karşılar ve açık fonksiyon çağrıları genellikle bir fallthrough zincirinden daha anlaşılırdır.

switch İçinde break

Bir case içindeki break, switch'ten çıkar. Case'ler kendiliğinden bittiği için ona yalnızca bir case'ten erken çıkmak için ihtiyaç duyarsınız. Tuzak, bir döngü içindeki switch'tir:

package main

import "fmt"

func main() {
	commands := []string{"a", "b", "quit", "c"}

loop:
	for _, cmd := range commands {
		switch cmd {
		case "quit":
			fmt.Println("quitting")
			break loop // a plain break would only leave the switch
		default:
			fmt.Println("run", cmd)
		}
	}
}

loop etiketi olmadan break switch'i bitirir ve döngü "c"'ye devam eder. Öte yandan continue her zaman çevreleyen döngüyü ifade eder, çünkü bir switch döngü değildir.

Tiplere Göre switch

Bir type switch, özel v.(type) biçimini kullanarak bir interface değerinin dinamik tipine göre dallanır:

package main

import "fmt"

func describe(v any) string {
	switch x := v.(type) {
	case nil:
		return "nil"
	case int, int64:
		return fmt.Sprintf("integer %v", x)
	case string:
		return fmt.Sprintf("string of length %d", len(x))
	case error:
		return "error: " + x.Error()
	default:
		return fmt.Sprintf("something else: %T", x)
	}
}

func main() {
	fmt.Println(describe(42))
	fmt.Println(describe("hello"))
	fmt.Println(describe(fmt.Errorf("boom")))
	fmt.Println(describe(3.14))
	fmt.Println(describe(nil))
}

Tek tipli bir case'te x o tipe sahiptir (string case'inde len(x) çalışır). Birkaç tip listeleyen bir case'te x interface tipini korur. Type assertion sayfası type switch'leri ve v.(T) assertion'ını ayrıntılı anlatıyor.

Go'nun switch'inin Farklı Yaptıkları

Case ifadelerinin sabit olması gerekmez. case limit(), max + 1: geçerlidir; biri eşleşene kadar sırayla değerlendirilirler, bu yüzden sonraki ifadeler hiç çalışmayabilir.

Kapsayıcılık

Go, bir enum üzerindeki switch'in her değeri kapsayıp kapsamadığını kontrol etmez. Beklemediğiniz değerler için loglayan, hata döndüren ya da panic yapan bir default ekleyin veya eksik case'lerin derleme zamanında raporlanması için exhaustive linter'ını (golangci-lint'in bir parçası) kullanın.