Switch case trong Golang: fallthrough và nhiều giá trị

Câu lệnh switch so sánh một giá trị với danh sách các case và chạy case khớp đầu tiên. Khác với C, Java và JavaScript, một case trong Go không rơi xuống case tiếp theo, nên không có break nào để bạn quên.

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

Các case được kiểm tra từ trên xuống dưới, và chỉ case khớp đầu tiên được chạy. default chạy khi không có gì khớp; nó là tùy chọn và có thể đặt ở bất kỳ đâu trong danh sách, dù theo quy ước thường đặt cuối cùng.

Nhiều giá trị trong một case

case "sat", "sun": khớp với một trong hai giá trị. Đây là cách Go diễn đạt điều mà C làm bằng các case rỗng xếp chồng. Kiểu nào so sánh được cũng dùng được: chuỗi, số, rune, boolean, con trỏ, và các kiểu đặt tên như enum:

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

Hai case có cùng giá trị hằng là lỗi biên dịch:

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

Switch không có điều kiện

Bỏ biểu thức đi thì mỗi case trở thành một phép kiểm tra boolean. Đây là dạng gọn gàng hơn của Go cho một chuỗi if/else if dài:

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 { là cách viết tắt của switch true {. Vì case đúng đầu tiên thắng, thứ tự là quan trọng: chỉ khi bmi < 18.5 sai thì mới đến bmi < 25, nên mỗi case có thể coi như các case phía trên đã không khớp.

Switch có câu lệnh khởi tạo

Giống if, một switch có thể bắt đầu bằng một câu lệnh ngắn. Biến khai báo ở đó chỉ có phạm vi trong 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)
		}
	}
}

Câu lệnh khởi tạo cũng kết hợp được với switch không có biểu thức: switch n := len(items); { case n == 0: ... }.

fallthrough

Khi bạn thật sự muốn chạy tiếp vào case sau, hãy viết fallthrough ở câu lệnh cuối của case. Nó chuyển quyền điều khiển sang thân của case tiếp theo mà không tính điều kiện của case đó:

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

Cấp 2 in ra write rồi read, cộng dồn quyền theo chiều đi xuống. Điều kiện của các case phía sau không được kiểm tra: sau fallthrough từ case 2, case 1 vẫn chạy dù level là 2.

Quy tắc của fallthrough:

• Nó phải là câu lệnh cuối cùng trong case.
• Nó không được nằm trong case cuối cùng: cannot fallthrough final case in switch.
• Nó không được dùng trong type switch.

Trên thực tế fallthrough hiếm gặp trong code Go. Nhiều giá trị trong một case đã đáp ứng nhu cầu phổ biến, và gọi hàm tường minh thường rõ ràng hơn một chuỗi fallthrough.

break trong switch

break bên trong một case sẽ thoát khỏi switch. Các case tự kết thúc, nên bạn chỉ cần nó khi muốn rời case sớm. Cái bẫy nằm ở switch bên trong vòng lặp:

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

Không có nhãn loop, break chỉ kết thúc switch và vòng lặp tiếp tục chạy tới "c". Ngược lại, continue luôn tác động lên vòng lặp bao quanh, vì switch không phải vòng lặp.

Switch theo kiểu

Type switch rẽ nhánh theo kiểu động của một giá trị interface, dùng dạng đặc biệt 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))
}

Trong case chỉ có một kiểu, x mang đúng kiểu đó (len(x) dùng được trong case string). Trong case liệt kê nhiều kiểu, x giữ nguyên kiểu interface. Trang về type assertion giải thích chi tiết type switch và phép khẳng định v.(T).

Những điểm switch của Go làm khác

Biểu thức của case không bắt buộc là hằng số. case limit(), max + 1: là hợp lệ; chúng được tính lần lượt cho đến khi một biểu thức khớp, nên các biểu thức phía sau có thể không bao giờ chạy.

Tính đầy đủ

Go không kiểm tra xem một switch trên enum đã bao quát mọi giá trị hay chưa. Hãy thêm một default ghi log, trả về lỗi hoặc panic với những giá trị bạn không lường trước, hoặc dùng linter exhaustive (một phần của golangci-lint) để các case còn thiếu được báo ngay lúc build.