Switch case en Golang : fallthrough et valeurs multiples

Un switch compare une valeur à une liste de cas et exécute le premier qui correspond. Contrairement à C, Java et JavaScript, un cas Go ne passe pas au suivant, donc il n'y a pas de break à oublier.

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

Les cas sont testés de haut en bas, et seul le premier cas correspondant s'exécute. default s'exécute quand rien ne correspond ; il est facultatif et peut apparaître n'importe où dans la liste, même si on le place en dernier par convention.

Plusieurs valeurs par cas

case "sat", "sun": correspond à l'une ou l'autre valeur. C'est ainsi que Go exprime ce que C fait avec des cas vides empilés. Tout type comparable fonctionne : chaînes, nombres, runes, booléens, pointeurs, et types nommés comme les 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))
	}
}

Deux cas avec la même valeur constante sont une erreur de compilation :

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

Switch sans condition

Omettez l'expression et chaque cas devient un test booléen. C'est la forme plus propre qu'offre Go pour une longue chaîne 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 { est un raccourci pour switch true {. Comme le premier cas vrai l'emporte, l'ordre compte : bmi < 25 n'est atteint que si bmi < 18.5 était faux, donc chaque cas peut supposer que ceux du dessus ont échoué.

Switch avec une instruction d'initialisation

Comme if, un switch peut commencer par une courte instruction. Les variables qui y sont déclarées ont une portée limitée au 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'instruction d'initialisation peut aussi se combiner avec un switch sans expression : switch n := len(items); { case n == 0: ... }.

fallthrough

Quand vous voulez vraiment continuer dans le cas suivant, écrivez fallthrough comme dernière instruction d'un cas. Il transfère le contrôle au corps du cas suivant sans évaluer sa condition :

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

Le niveau 2 affiche write puis read, en cumulant les permissions vers le bas. Les conditions des cas suivants ne sont pas testées : après fallthrough depuis case 2, case 1 s'exécute alors que level vaut 2.

Règles de fallthrough :

• Ce doit être la dernière instruction du cas.
• Il ne peut pas apparaître dans le dernier cas : cannot fallthrough final case in switch.
• Il n'est pas permis dans un type switch.

En pratique, fallthrough est rare dans le code Go. Les valeurs multiples par cas couvrent le besoin courant, et des appels de fonction explicites sont généralement plus clairs qu'une chaîne de fallthrough.

break dans un switch

break dans un cas quitte le switch. Les cas se terminent seuls, donc vous n'en avez besoin que pour quitter un cas plus tôt. Le piège est un switch à l'intérieur d'une boucle :

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

Sans l'étiquette loop, break termine le switch et la boucle continue jusqu'à "c". continue, en revanche, se rapporte toujours à la boucle englobante, puisqu'un switch n'est pas une boucle.

Switch sur les types

Un type switch branche sur le type dynamique d'une valeur interface, avec la forme spéciale 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))
}

Dans un cas avec un seul type, x a ce type (len(x) fonctionne dans le cas string). Dans un cas qui liste plusieurs types, x garde le type interface. La page sur les assertions de type traite en détail les type switches et l'assertion v.(T).

Ce que le switch de Go fait différemment

Les expressions des cas n'ont pas besoin d'être des constantes. case limit(), max + 1: est légal ; elles sont évaluées dans l'ordre jusqu'à ce qu'une corresponde, donc les suivantes peuvent ne jamais s'exécuter.

Exhaustivité

Go ne vérifie pas qu'un switch sur un enum couvre toutes les valeurs. Ajoutez un default qui journalise, renvoie une erreur ou provoque un panic pour les valeurs inattendues, ou utilisez le linter exhaustive (inclus dans golangci-lint) pour que les cas manquants soient signalés à la compilation.