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 بالحالات الفارغة المكدّسة. يعمل أي نوع قابل للمقارنة: النصوص والأرقام والـ runes والقيم المنطقية والمؤشرات والأنواع المسمّاة مثل التعدادات:

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 خاطئًا، فتستطيع كل حالة افتراض أن الحالات التي قبلها فشلت.

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. القيم المتعدّدة لكل حالة تغطّي الحاجة الشائعة، والاستدعاءات الصريحة للدوال أوضح عادة من سلسلة fallthrough.

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 حسب النوع الديناميكي لقيمة واجهة، باستخدام الصيغة الخاصة 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 بنوع الواجهة. صفحة تأكيدات النوع تشرح type switch والتأكيد v.(T) بالتفصيل.

ما تفعله switch في Go بشكل مختلف

لا يجب أن تكون تعابير الحالات ثوابت. case limit(), max + 1: مسموحة؛ وتُقيَّم بالترتيب حتى تطابق إحداها، فقد لا تُنفَّذ التعابير اللاحقة أبدًا.

الشمول

لا تتحقّق Go من أن switch على تعداد يغطّي كل قيمة. أضف default تسجّل أو تعيد خطأ أو تسبّب panic للقيم التي لم تتوقّعها، أو استخدم أداة الفحص exhaustive (جزء من golangci-lint) ليُبلَّغ عن الحالات الناقصة وقت البناء.