Go - The Switch Statement

UMA switchinstrução permite que uma variável seja testada quanto à igualdade em relação a uma lista de valores. Cada valor é chamado de caso, e a variável que está sendo ligada é verificada para cadaswitch case.

Na programação Go, as instruções switch são de dois tipos -

Expression Switch - Na troca de expressão, um caso contém expressões, que são comparadas com o valor da expressão de troca.
Type Switch - Na troca de tipo, um caso contém o tipo que é comparado com o tipo de uma expressão de troca especialmente anotada.

Expression Switch

A sintaxe para expression switch declaração na linguagem de programação Go é a seguinte -

switch(boolean-expression or integral type){
   case boolean-expression or integral type :
      statement(s);      
   case boolean-expression or integral type :
      statement(s); 
   
   /* you can have any number of case statements */
   default : /* Optional */
      statement(s);
}

As seguintes regras se aplicam a um switch declaração -

o expression usado em um switchdeclaração deve ter uma expressão integral ou booleana, ou ser de um tipo de classe em que a classe tem uma única função de conversão para um valor integral ou booleano. Se a expressão não for passada, o valor padrão é verdadeiro.
Você pode ter qualquer número de declarações de caso em um switch. Cada caso é seguido pelo valor a ser comparado e dois pontos.
o constant-expression para um caso, deve ser do mesmo tipo de dados que a variável no switch e deve ser uma constante ou literal.
Quando a variável sendo ativada é igual a um caso, as instruções que seguem aquele caso serão executadas. Nãobreak é necessário na instrução case.
UMA switch declaração pode ter um opcional defaultcaso, que deve aparecer no final do switch. O caso padrão pode ser usado para executar uma tarefa quando nenhum dos casos for verdadeiro. Nãobreak é necessário no caso padrão.

Diagrama de fluxo

Exemplo

package main

import "fmt"

func main() {
   /* local variable definition */
   var grade string = "B"
   var marks int = 90

   switch marks {
      case 90: grade = "A"
      case 80: grade = "B"
      case 50,60,70 : grade = "C"
      default: grade = "D"  
   }
   switch {
      case grade == "A" :
         fmt.Printf("Excellent!\n" )     
      case grade == "B", grade == "C" :
         fmt.Printf("Well done\n" )      
      case grade == "D" :
         fmt.Printf("You passed\n" )      
      case grade == "F":
         fmt.Printf("Better try again\n" )
      default:
         fmt.Printf("Invalid grade\n" );
   }
   fmt.Printf("Your grade is  %s\n", grade );      
}

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

Excellent!
Your grade is  A

Chave de tipo

A sintaxe para um type switch declaração na programação Go é a seguinte -

switch x.(type){
   case type:
      statement(s);      
   case type:
      statement(s); 
   /* you can have any number of case statements */
   default: /* Optional */
      statement(s);
}

As seguintes regras se aplicam a um switch declaração -

o expression usado em um switch declaração deve ter uma variável do tipo interface {}.
Você pode ter qualquer número de declarações de caso em um switch. Cada caso é seguido pelo valor a ser comparado e dois pontos.
O tipo para um caso deve ser o mesmo tipo de dados que a variável na chave e deve ser um tipo de dados válido.
Quando a variável sendo ativada é igual a um caso, as instruções que seguem aquele caso serão executadas. Nenhuma pausa é necessária na instrução do caso.
Uma instrução switch pode ter um caso padrão opcional, que deve aparecer no final da switch. O caso padrão pode ser usado para executar uma tarefa quando nenhum dos casos for verdadeiro. Nenhuma pausa é necessária no caso padrão.

Exemplo

package main

import "fmt"

func main() {
   var x interface{}
     
   switch i := x.(type) {
      case nil:	  
         fmt.Printf("type of x :%T",i)                
      case int:	  
         fmt.Printf("x is int")                       
      case float64:
         fmt.Printf("x is float64")           
      case func(int) float64:
         fmt.Printf("x is func(int)")                      
      case bool, string:
         fmt.Printf("x is bool or string")       
      default:
         fmt.Printf("don't know the type")     
   }   
}

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

type of x :<nil>

↰ Previous page