Go - La déclaration Switch

UNE switchL'instruction permet à une variable d'être testée pour l'égalité par rapport à une liste de valeurs. Chaque valeur est appelée un cas, et la variable activée est vérifiée pour chaqueswitch case.

Dans la programmation Go, les instructions switch sont de deux types -

• Expression Switch - Dans le commutateur d'expression, un cas contient des expressions, qui sont comparées à la valeur de l'expression de commutateur.

• Type Switch - Dans un commutateur de type, un cas contient un type qui est comparé au type d'une expression de commutateur spécialement annotée.

Commutateur d'expression

La syntaxe de expression switch l'instruction dans le langage de programmation Go est la suivante -

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

Les règles suivantes s'appliquent à un switch déclaration -

• le expression utilisé dans un switchL'instruction doit avoir une expression intégrale ou booléenne, ou être d'un type de classe dans lequel la classe a une seule fonction de conversion en une valeur intégrale ou booléenne. Si l'expression n'est pas transmise, la valeur par défaut est true.

• Vous pouvez avoir n'importe quel nombre d'instructions case dans un commutateur. Chaque cas est suivi de la valeur à comparer et d'un signe deux-points.

• le constant-expression pour un cas doit être du même type de données que la variable dans le commutateur, et ce doit être une constante ou un littéral.

• Lorsque la variable activée est égale à un cas, les instructions suivant ce cas s'exécutent. Nonbreak est nécessaire dans la déclaration de cas.

• UNE switch l'instruction peut avoir une option defaultcas, qui doit apparaître à la fin du commutateur. Le cas par défaut peut être utilisé pour exécuter une tâche lorsque aucun des cas n'est vrai. Nonbreak est nécessaire dans le cas par défaut.

Représentation schématique

Exemple

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

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

Excellent!
Your grade is  A

Commutateur de type

La syntaxe d'un type switch L'instruction dans la programmation Go est la suivante -

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

Les règles suivantes s'appliquent à un switch déclaration -

• le expression utilisé dans un switch L'instruction doit avoir une variable de type interface {}.

• Vous pouvez avoir n'importe quel nombre d'instructions case dans un commutateur. Chaque cas est suivi de la valeur à comparer et d'un signe deux-points.

• Le type d'un cas doit être du même type de données que la variable du commutateur et il doit s'agir d'un type de données valide.

• Lorsque la variable activée est égale à un cas, les instructions suivant ce cas s'exécutent. Aucune interruption n'est nécessaire dans l'énoncé de cas.

• Une instruction switch peut avoir une casse par défaut facultative, qui doit apparaître à la fin du switch. Le cas par défaut peut être utilisé pour exécuter une tâche lorsque aucun des cas n'est vrai. Aucune pause n'est nécessaire dans le cas par défaut.

Exemple

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

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

type of x :<nil>