Sentenças Switch da Linguagem Go

A instrução switch é uma instrução de ramificação múltipla. Ela oferece um método eficaz para transferir a execução para diferentes partes do código com base no valor da expressão (também chamada de case). O linguagem Go suporta dois tipos de instruções switch:

1. expressão switch

2. Switch de tipo

expressão switch

A expressão switch é semelhante ao C, C ++A instrução switch no Java. Ela oferece um método simples para dispatchar a execução para diferentes partes do código com base no valor da expressão.

Sintaxe:

switch optstatement; optexpression{
　　　　case expression1: Statement..
　　　　case expression2: Statement..
　　　　...
　　　　padrão: Statement..
}

Ponto importante:

• As optstatement e optexpression na expressão switch são instruções opcionais.

• Se existiremoptstatementeoptpressionEntão, entre eles, é necessário usar ponto e vírgula (;).

• Se o switch não contiver nenhuma expressão, o compilador assume que essa expressão é true.

• A instrução opcional, ou optstatement, contém instruções simples, como declaração de variável, instruções de aumento ou atribuição ou chamadas de função, etc.

• Se houver uma variável na instrução opcional, o escopo dessa variável é limitado à instrução switch.

• No switch, as instruções case e default não contêm nenhuma instrução break. Mas se seu programa precisar, você pode usar as instruções break e fallthrough.

• A instrução padrão (default) na instrução switch é opcional.

• Se um caso puder conter vários valores, separados por vírgula (,).

• Se um caso não contiver nenhuma expressão, o compilador assume que essa expressão é true.

Exemplo de como obter qual dia da semana é um número específico:

package main
import "fmt"
func main() {
　　　　//　A instrução switch usa dois tipos de语句, como o opcional, day :=4　e expressão, por exemplo: 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")
　　　　padrão:
　　　　　　　　fmt.Println("Invalid")
　　　　}
}

Saída:

Thursday

Exemplo de instrução switch sem expressão ou语句opcional

package main　
　　
import "fmt"
　　
func main() {　
　　　　var value int =　2　
　　　　　　
　　　　　　//　A instrução switch não possui expressão ou语句opcional
　　　switch {　
　　　　　　　case value ==　1:　
　　　　　　　fmt.Println("Hello")　
　　　　　　　case value ==　2:　
　　　　　　　fmt.Println("Bonjour")　
　　　　　　　case value ==　3:　
　　　　　　　fmt.Println("Namstay")　
　　　　　　　padrão:　　
　　　　　　　fmt.Println("Invalid")　
　　　}　
　　
}

Saída:

Bonjour

Aqui está uma instrução switch sem expressão padrão, múltiplos valores no caso da instrução:

package main
import "fmt"
func main() {
　　　　var value string = "five"
　　　　//Instrução switch sem cláusula padrão, múltiplos valores no caso
　　　　switch value {
　　　　case "one":
　　　　　　　　fmt.Println("C#")
　　　　case "two", "three":
　　　　　　　　fmt.Println("Go")
　　　　case "four", "five", "six":
　　　　　　　　fmt.Println("Java")
　　　　}
}

Saída:

Java

Switch de tipo

Quando você deseja comparar tipos, use o switch de tipo. Neste switch, a cláusula case contém os tipos a serem comparados com os tipos que aparecem na expressão switch.

Sintaxe:

switch optstatement; typeswitchexpression{
　　　　case typelist　1: Statement..
　　　　case typelist　2: Statement..
　　　　...
　　　　padrão: Statement..
}

Ponto importante:

• Cláusula opcional, ou optstatement, semelhante à expressão switch.

• Se um caso puder conter vários valores, separados por vírgula (,).

• Na instrução switch de tipo, as cláusulas case e padrão não contêm nenhuma instrução break. No entanto, se o programa precisar, podem ser usadas as instruções break e fallthrough.

• Na instrução switch de tipo, a cláusula padrão é opcional.

• typeswitchexpressioné uma expressão cujo resultado é um tipo.

• Se a expressão typeswitchexpression atribuiu uma expressão usando o operador :=, o tipo da variável depende do tipo da cláusula case. Se a cláusula case contiver dois ou mais tipos, o tipo da variável é o tipo criado na expressão typeswitchexpression.

package main
import "fmt"
func main() {
　　　　var value interface{}
　　　　switch q := value.(type) {
　　　　case bool:
　　　　　　　　fmt.Println("O valor é booleano")
　　　　case float64:
　　　　　　　　fmt.Println("O valor é float")64Tipo)
　　　　case int:
　　　　　　　　fmt.Println("O valor é do tipo int")
　　　　padrão:
　　　　　　　　fmt.Printf("O tipo do valor é: %T", q)
　　　　}
}

Saída:

O tipo do valor é: <nil>