Go - La dichiarazione Switch

UN switchconsente di verificare l'uguaglianza di una variabile rispetto a un elenco di valori. Ogni valore è chiamato caso e per ciascuno di essi viene controllata la variabile attivataswitch case.

Nella programmazione Go, le istruzioni switch sono di due tipi:

  • Expression Switch - In expression switch, un case contiene espressioni, che vengono confrontate con il valore dell'espressione switch.

  • Type Switch - In type switch, un case contiene il tipo che viene confrontato con il tipo di un'espressione switch appositamente annotata.

Interruttore di espressione

La sintassi per expression switch L'istruzione nel linguaggio di programmazione Go è la seguente:

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

Le seguenti regole si applicano a un file switch dichiarazione -

  • Il expression utilizzato in a switchl'istruzione deve avere un'espressione integrale o booleana oppure essere di un tipo di classe in cui la classe ha una singola funzione di conversione in un valore integrale o booleano. Se l'espressione non viene passata, il valore predefinito è vero.

  • È possibile avere un numero qualsiasi di istruzioni case all'interno di uno switch. Ogni caso è seguito dal valore da confrontare e da due punti.

  • Il constant-expression per un caso deve essere lo stesso tipo di dati della variabile nello switch e deve essere una costante o un valore letterale.

  • Quando la variabile da attivare è uguale a un case, verranno eseguite le istruzioni che seguono quel caso. Nobreak è necessario nell'istruzione case.

  • UN switch l'istruzione può avere un optional defaultcaso, che deve apparire alla fine dell'interruttore. Il caso predefinito può essere utilizzato per eseguire un'attività quando nessuno dei casi è vero. Nobreak è necessario nel caso predefinito.

Diagramma di flusso

Esempio

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 il codice precedente viene compilato ed eseguito, produce il seguente risultato:

Excellent!
Your grade is  A

Tipo Switch

La sintassi per a type switch l'istruzione nella programmazione Go è la seguente:

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

Le seguenti regole si applicano a un file switch dichiarazione -

  • Il expression utilizzato in a switch l'istruzione deve avere una variabile di tipo {} interfaccia.

  • È possibile avere un numero qualsiasi di istruzioni case all'interno di uno switch. Ogni caso è seguito dal valore da confrontare e da due punti.

  • Il tipo per un caso deve essere lo stesso tipo di dati della variabile nello switch e deve essere un tipo di dati valido.

  • Quando la variabile da attivare è uguale a un case, verranno eseguite le istruzioni che seguono quel caso. Non è necessaria alcuna interruzione nell'istruzione case.

  • Un'istruzione switch può avere un caso predefinito opzionale, che deve essere visualizzato alla fine dello switch. Il caso predefinito può essere utilizzato per eseguire un'attività quando nessuno dei casi è vero. Non è necessaria alcuna interruzione nel caso predefinito.

Esempio

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 il codice precedente viene compilato ed eseguito, produce il seguente risultato:

type of x :<nil>