switch case in Golang: fallthrough e valori multipli

Uno switch confronta un valore con un elenco di casi ed esegue la prima corrispondenza. A differenza di C, Java e JavaScript, un caso in Go non prosegue nel successivo, quindi non c'è nessun break da dimenticare.

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

I casi vengono controllati dall'alto verso il basso, e viene eseguito solo il primo che corrisponde. default viene eseguito quando nulla corrisponde; è facoltativo e può stare in qualsiasi punto dell'elenco, anche se per convenzione va per ultimo.

Più valori per caso

case "sat", "sun": corrisponde a uno qualsiasi dei due valori. È così che Go esprime ciò che il C fa con i casi vuoti impilati. Funziona con qualsiasi tipo confrontabile: stringhe, numeri, rune, booleani, puntatori e tipi con nome come gli 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))
	}
}

Due casi con lo stesso valore costante sono un errore di compilazione:

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

switch senza condizione

Ometti l'espressione e ogni caso diventa un test booleano. È la forma più pulita che Go offre per una lunga catena 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 { è un'abbreviazione di switch true {. Dato che vince il primo caso vero, l'ordine conta: bmi < 25 viene raggiunto solo quando bmi < 18.5 era falso, quindi ogni caso può dare per scontato che quelli sopra siano falliti.

switch con istruzione di inizializzazione

Come if, anche uno switch può iniziare con una breve istruzione. Le variabili dichiarate lì sono visibili solo dentro lo 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)
		}
	}
}

L'istruzione di inizializzazione si può combinare anche con uno switch senza condizione: switch n := len(items); { case n == 0: ... }.

fallthrough

Quando vuoi davvero continuare nel caso successivo, scrivi fallthrough come ultima istruzione di un caso. Passa il controllo al corpo del caso successivo senza valutarne la condizione:

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

Il livello 2 stampa write e poi read, accumulando i permessi verso il basso. Le condizioni dei casi successivi non vengono controllate: dopo il fallthrough da case 2, case 1 viene eseguito anche se level vale 2.

Regole per fallthrough:

• Deve essere l'ultima istruzione del caso.
• Non può comparire nell'ultimo caso: cannot fallthrough final case in switch.
• Non è ammesso in un type switch.

In pratica fallthrough è raro nel codice Go. I valori multipli per caso coprono l'esigenza comune, e chiamate esplicite a funzioni sono di solito più chiare di una catena di fallthrough.

break in uno switch

break dentro un caso esce dallo switch. I casi finiscono da soli, quindi ti serve solo per uscire in anticipo da un caso. La trappola è uno switch dentro un ciclo:

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

Senza l'etichetta loop, break termina lo switch e il ciclo prosegue fino a "c". continue, invece, si riferisce sempre al ciclo che lo contiene, perché uno switch non è un ciclo.

switch sui tipi

Un type switch si dirama in base al tipo dinamico di un valore interfaccia, usando la forma speciale 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))
}

In un caso con un solo tipo, x ha quel tipo (len(x) funziona nel caso string). In un caso che elenca più tipi, x mantiene il tipo interfaccia. La pagina sulle type assertion tratta in dettaglio i type switch e l'asserzione v.(T).

Cosa fa diversamente lo switch di Go

Le espressioni dei casi non devono essere per forza costanti. case limit(), max + 1: è valido; vengono valutate in ordine finché una non corrisponde, quindi le espressioni successive potrebbero non essere mai eseguite.

Esaustività

Go non controlla che uno switch su un enum copra ogni valore. Aggiungi un default che registra un log, restituisce un errore o va in panic per i valori che non ti aspettavi, oppure usa il linter exhaustive (parte di golangci-lint) per farti segnalare i casi mancanti in fase di build.