Switch case ב-Golang: fallthrough וכמה ערכים במקרה אחד

switch משווה ערך אחד לרשימה של מקרים ומריצה את ההתאמה הראשונה. בניגוד ל-C, ל-Java ול-JavaScript, מקרה ב-Go לא נופל הלאה למקרה הבא, כך שאין break לשכוח.

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

המקרים נבדקים מלמעלה למטה, ורק המקרה המתאים הראשון רץ. default רץ כששום דבר לא מתאים; הוא אופציונלי ויכול להופיע בכל מקום ברשימה, אבל לפי המוסכמה הוא בא אחרון.

כמה ערכים לכל מקרה

case "sat", "sun": מתאים לכל אחד מהערכים. כך Go מבטאת את מה ש-C עושה עם מקרים ריקים מוערמים. כל טיפוס comparable עובד: מחרוזות, מספרים, runes, בוליאנים, מצביעים וטיפוסים עם שם כמו enums:

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

שני מקרים עם אותו ערך קבוע הם שגיאת הידור:

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

Switch בלי תנאי

השמיטו את הביטוי וכל מקרה הופך לבדיקה בוליאנית. זו הצורה הנקייה יותר של Go לשרשרת ארוכה של if/else if:

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 {. מכיוון שהמקרה הראשון שמתקיים מנצח, הסדר חשוב: מגיעים ל-bmi < 25 רק כש-bmi < 18.5 היה false, כך שכל מקרה יכול להניח שהמקרים שלפניו נכשלו.

Switch עם פקודת אתחול

כמו if, switch יכולה להתחיל בפקודה קצרה. משתנים שמוצהרים שם תקפים רק בתוך ה-switch:

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

אפשר לשלב את פקודת האתחול גם עם switch בלי ביטוי: switch n := len(items); { case n == 0: ... }.

fallthrough

כשכן רוצים להמשיך למקרה הבא, כתבו fallthrough כפקודה האחרונה של מקרה. הוא מעביר את השליטה לגוף של המקרה הבא בלי להעריך את התנאי שלו:

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

רמה 2 מדפיסה write ואחר כך read, וצוברת הרשאות כלפי מטה. התנאים של המקרים הבאים לא נבדקים: אחרי fallthrough מ-case 2, case 1 רץ למרות ש-level הוא 2.

כללים ל-fallthrough:

• הוא חייב להיות הפקודה האחרונה במקרה.
• הוא לא יכול להופיע במקרה האחרון: cannot fallthrough final case in switch.
• הוא לא מותר ב-type switch.

בפועל fallthrough נדיר בקוד Go. כמה ערכים לכל מקרה מכסים את הצורך הנפוץ, וקריאות מפורשות לפונקציות בדרך כלל ברורות יותר משרשרת של fallthroughs.

break בתוך switch

break בתוך מקרה יוצא מה-switch. מקרים נגמרים מעצמם, כך שצריך אותו רק כדי לצאת ממקרה מוקדם. המלכודת היא switch בתוך לולאה:

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, break מסיים את ה-switch והלולאה ממשיכה ל-"c". continue, לעומת זאת, תמיד מתייחס ללולאה העוטפת, כי switch היא לא לולאה.

Switch לפי טיפוסים

type switch מתפצל לפי הטיפוס הדינמי של ערך interface, בעזרת הצורה המיוחדת v.(type):

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

במקרה עם טיפוס יחיד, ל-x יש את הטיפוס הזה (len(x) עובד במקרה של string). במקרה שמפרט כמה טיפוסים, x שומר על טיפוס ה-interface. הדף על type assertions מכסה type switches ואת ה-assertion v.(T) לעומק.

מה ש-switch של Go עושה אחרת

ביטויי מקרה לא חייבים להיות קבועים. case limit(), max + 1: חוקי; הם מוערכים לפי הסדר עד שאחד מתאים, כך שביטויים מאוחרים יותר עשויים לא לרוץ אף פעם.

כיסוי מלא

Go לא בודקת ש-switch על enum מכסה כל ערך. הוסיפו default שרושם ללוג, מחזיר שגיאה או גורם ל-panic בערכים שלא ציפיתם להם, או השתמשו ב-linter בשם exhaustive (חלק מ-golangci-lint) כדי שמקרים חסרים ידווחו בזמן ה-build.