Condizionali switch in

Informazioni su Condizionali switch

Un'istruzione switch valuta un'espressione ed esegue il primo case che corrisponde al suo valore. Spesso è un'alternativa più pulita alle lunghe catene di if ... else if.

Utilizzo di base

operatingSystem := "windows"

switch operatingSystem {
case "windows":
    // do something if the operating system is windows
case "linux":
    // do something if the operating system is linux
case "macos":
    // do something if the operating system is macos
default:
    // do something if the operating system is none of the above
}

È possibile raggruppare più valori in un unico case separandoli con una virgola. Il case corrisponde se l'espressione è uguale a uno qualsiasi di questi valori:

switch operatingSystem {
case "windows", "linux":
    // do something if the operating system is windows or linux
case "macos":
    // do something if the operating system is macos
default:
    // do something if the operating system is none of the above
}

Switch senza espressione

L'espressione dopo switch può anche essere omessa del tutto. Ogni case contiene quindi un'espressione booleana: viene eseguito il primo il cui valore è true.

age := 21

switch {
case age > 20 && age < 30:
    // do something if age is between 20 and 30
case age == 10:
    // do something if age is equal to 10
default:
    // do something else for every other case
}

Istruzione di inizializzazione

Come if, anche un switch può includere una breve istruzione di inizializzazione prima dell'espressione. Le variabili dichiarate lì hanno come scope il blocco dello switch:

switch v := getValue(); {
case v < 0:
    // do something if v is less than 0
case v == 0:
    // do something if v is 0
default:
    // do something else for every other case
}
// v will not be accessible here

Fallthrough

fallthrough fa sì che venga eseguito il corpo del case successivo, indipendentemente dal fatto che la sua espressione corrisponda o meno. Deve essere l'ultima istruzione del corpo del case e deve esserci un case successivo da eseguire.

fallthrough è poco comune nel Go idiomatico, perché rende i case adiacenti dipendenti l'uno dall'altro. Di conseguenza, è più difficile ragionare sui singoli case presi isolatamente e lo switch diventa più difficile da leggere. Quando più case devono avere lo stesso comportamento, è più chiaro raggrupparli con una virgola. Quando invece la logica è condivisa tra più case per altri motivi, valuta di estrarla in una funzione ausiliaria.

s := "hello"

switch s {
case "hello":
    fmt.Println("hello")
    fallthrough
case "world":
    fmt.Println("world") // also runs, even though s != "world"
}
// Output:
// hello
// world

Per saperne di più, dai un'occhiata a Go by Example: Switch o alla specifica del linguaggio Go.