Switch Case di Golang: fallthrough dan Banyak Nilai

switch membandingkan satu nilai dengan daftar case dan menjalankan case pertama yang cocok. Berbeda dari C, Java, dan JavaScript, case di Go tidak berlanjut ke case berikutnya, jadi tidak ada break yang bisa terlupa.

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 diperiksa dari atas ke bawah, dan hanya case pertama yang cocok yang dijalankan. default dijalankan ketika tidak ada yang cocok; bagian ini opsional dan bisa muncul di mana saja dalam daftar, walaupun menurut konvensi ditaruh paling akhir.

Banyak nilai per case

case "sat", "sun": cocok dengan salah satu nilai itu. Inilah cara Go menuliskan apa yang di C dilakukan dengan menumpuk case kosong. Tipe apa pun yang bisa dibandingkan bisa dipakai: string, angka, rune, boolean, pointer, dan tipe bernama seperti 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))
	}
}

Dua case dengan nilai konstanta yang sama adalah error kompilasi:

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

Switch tanpa kondisi

Hilangkan ekspresinya, dan setiap case menjadi pengujian boolean. Inilah bentuk yang lebih rapi di Go untuk rangkaian if/else if yang panjang:

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 { adalah singkatan dari switch true {. Karena case pertama yang bernilai true yang menang, urutan itu penting: bmi < 25 hanya dicapai ketika bmi < 18.5 bernilai false, jadi setiap case boleh menganggap case di atasnya sudah gagal.

Switch dengan pernyataan init

Seperti if, switch bisa diawali pernyataan singkat. Variabel yang dideklarasikan di sana hanya berlaku di dalam 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)
		}
	}
}

Pernyataan init juga bisa digabung dengan switch tanpa kondisi: switch n := len(items); { case n == 0: ... }.

fallthrough

Kalau kamu memang ingin berlanjut ke case berikutnya, tulis fallthrough sebagai pernyataan terakhir sebuah case. Kata kunci ini memindahkan kendali ke badan case berikutnya tanpa mengevaluasi kondisinya:

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

Level 2 mencetak write lalu read, mengumpulkan izin ke bawah. Kondisi case-case berikutnya tidak diperiksa: setelah fallthrough dari case 2, case 1 tetap dijalankan walaupun level bernilai 2.

Aturan untuk fallthrough:

• Harus menjadi pernyataan terakhir di dalam case.
• Tidak boleh muncul di case terakhir: cannot fallthrough final case in switch.
• Tidak diizinkan di type switch.

Dalam praktiknya, fallthrough jarang dipakai di kode Go. Banyak nilai per case sudah mencakup kebutuhan yang umum, dan pemanggilan fungsi yang eksplisit biasanya lebih jelas daripada rangkaian fallthrough.

break di dalam switch

break di dalam case keluar dari switch. Case berakhir dengan sendirinya, jadi kamu hanya membutuhkannya untuk keluar dari case lebih awal. Jebakannya adalah switch di dalam perulangan:

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

Tanpa label loop, break hanya mengakhiri switch dan perulangan terus berjalan sampai "c". Sebaliknya, continue selalu mengacu pada perulangan yang membungkusnya, karena switch bukan perulangan.

Switch berdasarkan tipe

Type switch bercabang berdasarkan tipe dinamis dari sebuah nilai interface, dengan bentuk khusus 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))
}

Di case dengan satu tipe, x bertipe itu (len(x) bisa dipakai di case string). Di case yang berisi beberapa tipe, x tetap bertipe interface. Halaman type assertion membahas type switch dan assertion v.(T) secara lengkap.

Hal yang dilakukan switch Go secara berbeda

Ekspresi case tidak harus berupa konstanta. case limit(), max + 1: itu sah; ekspresi-ekspresi itu dievaluasi berurutan sampai ada yang cocok, jadi ekspresi yang lebih belakang mungkin tidak pernah dijalankan.

Kelengkapan case

Go tidak memeriksa apakah switch atas sebuah enum sudah mencakup semua nilainya. Tambahkan default yang mencatat log, mengembalikan error, atau panic untuk nilai yang tidak kamu duga, atau pakai linter exhaustive (bagian dari golangci-lint) agar case yang terlewat dilaporkan saat build.