Switch del linguaggio Go

La struttura switch è una struttura di branching multipla. Fornisce un metodo efficace per trasferire l'esecuzione a parti diverse del codice in base al valore dell'espressione (noto anche come case). Go supporta due tipi di strutture switch:

1. Espressione switch

2. Type switch

Espressione switch

L'espressione switch è simile alla struttura switch nei linguaggi C, C++, Java. Fornisce un metodo semplice per assegnare l'esecuzione a parti diverse del codice in base al valore dell'espressione.

Sintassi:

switch optstatement; optexpression{
　　　　case espressione1: Statement..
　　　　case espressione2: Statement..
　　　　...
　　　　default: Statement..
}

Punti importanti:

• espressioni opzionali optstatement e optexpression all'interno di una espressione switch sono opzionali.

• se presenti contemporaneamenteoptstatementeoptpressionse sono presenti, tra di esse devono essere utilizzati i punti e virgola (;).

• Se lo switch non contiene alcuna espressione, il compilatore assume che l'espressione sia true.

• L'espressione opzionale, ovvero optstatement, contiene semplici istruzioni, come dichiarazioni di variabili, istruzioni di incrementazione o assegnazione o chiamate di funzione, ecc.

• Se l'espressione opzionale contiene una variabile, l'ambito di questa variabile è limitato all'istruzione switch.

• Nelle istruzioni switch, i casi e le istruzioni di default non contengono alcuna istruzione break. Ma se il tuo programma lo richiede, puoi utilizzare le istruzioni break e fallthrough.

• La dichiarazione di default (default) nelle istruzioni switch è opzionale.

• Un caso può contenere più valori, separati da virgola (,).

• Se un caso non contiene alcuna espressione, il compilatore assume che l'espressione sia true.

Esempio di come ottenere il giorno della settimana di un numero specifico:

package main
import "fmt"
func main() {
　　　　// Switch utilizza sia espressioni opzionali, come day:=4, che espressioni come: day
　　　　switch day := 4; day {
　　　　case 1:
　　　　　　　　fmt.Println("Monday")
　　　　case 2:
　　　　　　　　fmt.Println("Tuesday")
　　　　case 3:
　　　　　　　　fmt.Println("Wednesday")
　　　　case 4:
　　　　　　　　fmt.Println("Thursday")
　　　　case 5:
　　　　　　　　fmt.Println("Friday")
　　　　case 6:
　　　　　　　　fmt.Println("Saturday")
　　　　case 7:
　　　　　　　　fmt.Println("Sunday")
　　　　default:
　　　　　　　　fmt.Println("Invalid")
　　　　}
}

Output:

Thursday

Esempio di switch senza espressioni e opzionale:

package main　
　　
import "fmt"
　　
func main() {　
　　　　var value int = 2　
　　　　　　
　　　　　　// switch senza espressioni e opzionale
　　　switch {　
　　　　　　　case value == 1:　
　　　　　　　fmt.Println("Hello")　
　　　　　　　case value == 2:　
　　　　　　　fmt.Println("Bonjour")　
　　　　　　　case value == 3:　
　　　　　　　fmt.Println("Namstay")　
　　　　　　　default:　　
　　　　　　　fmt.Println("Invalid")　
　　　}　
　　
}

Output:

Bonjour

Ecco un'istruzione switch senza caso predefinito, più valori nel caso:

package main
import "fmt"
func main() {
　　　　var value string = "five"
　　　　//Switch statement senza dichiarazione di default, i casi possono contenere più valori
　　　　switch value {
　　　　case "one":
　　　　　　　　fmt.Println("C#")
　　　　case "two", "three":
　　　　　　　　fmt.Println("Go")
　　　　case "four", "five", "six":
　　　　　　　　fmt.Println("Java")
　　　　}
}

Output:

Java

Type switch

Quando si desidera confrontare i tipi, utilizzare il tipo di switch. In questo switch, i casi contengono i tipi da confrontare con quelli presenti nell'espressione del switch.

Sintassi:

switch optstatement; typeswitchexpression{
　　　　case typelist 1: Statement..
　　　　case typelist 2: Statement..
　　　　...
　　　　default: Statement..
}

Punti importanti:

• Dichiarazione opzionale, ovvero optstatement, simile a quella dell'espressione switch.

• Un caso può contenere più valori, separati da virgola (,).

• Nella dichiarazione di tipo switch, le dichiarazioni case e default non contengono alcun break. Ma se necessario, possono essere utilizzati break e fallthrough.

• La dichiarazione di default è opzionale nei tipi di switch.

• typeswitchexpressionÈ un'espressione che ha come risultato un tipo.

• Se viene assegnato un'espressione utilizzando l'operatore := in un'espressione typeswitch, il tipo della variabile dipende dal tipo specificato nel caso. Se il caso contiene due o più tipi, il tipo della variabile è quello creato nell'espressione typeswitch.

package main
import "fmt"
func main() {
　　　　var value interface{}
　　　　switch q := value.(type) {
　　　　case bool:
　　　　　　　　fmt.Println("Il valore è di tipo booleano")
　　　　case float64:
　　　　　　　　fmt.Println("Il valore è di tipo float64")
　　　　case int:
　　　　　　　　fmt.Println("Il valore è di tipo int")
　　　　default:
　　　　　　　　fmt.Printf("Il tipo del valore è: %T", q)
　　　　}
}

Output:

Il tipo del valore è: <nil>