Go - La declaración de cambio

UNA switchLa declaración permite probar la igualdad de una variable con una lista de valores. Cada valor se llama caso, y la variable que se enciende se verifica para cadaswitch case.

En la programación de Go, las declaraciones de cambio son de dos tipos:

Expression Switch - En cambio de expresión, un caso contiene expresiones, que se comparan con el valor de la expresión del cambio.
Type Switch - En el tipo de cambio, un caso contiene un tipo que se compara con el tipo de una expresión de cambio especialmente anotada.

Interruptor de expresión

La sintaxis de expression switch declaración en el lenguaje de programación Go es la siguiente:

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

Las siguientes reglas se aplican a switch declaración -

los expression usado en un switchLa declaración debe tener una expresión integral o booleana, o ser de un tipo de clase en el que la clase tenga una única función de conversión a un valor integral o booleano. Si no se pasa la expresión, el valor predeterminado es verdadero.
Puede tener cualquier número de declaraciones de casos dentro de un conmutador. Cada caso va seguido del valor que se va a comparar y dos puntos.
los constant-expression para un caso debe ser del mismo tipo de datos que la variable en el conmutador, y debe ser una constante o un literal.
Cuando la variable que se enciende es igual a un caso, se ejecutarán las declaraciones que siguen a ese caso. Nobreak es necesario en la declaración del caso.
UNA switch declaración puede tener un opcional defaultcaso, que debe aparecer al final del interruptor. El caso predeterminado se puede utilizar para realizar una tarea cuando ninguno de los casos es verdadero. Nobreak es necesario en el caso predeterminado.

Diagrama de flujo

Ejemplo

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

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

Excellent!
Your grade is  A

Tipo de interruptor

La sintaxis de un type switch La declaración en la programación de Go es la siguiente:

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

Las siguientes reglas se aplican a switch declaración -

los expression usado en un switch declaración debe tener una variable de tipo interfaz {}.
Puede tener cualquier número de declaraciones de casos dentro de un conmutador. Cada caso va seguido del valor que se va a comparar y dos puntos.
El tipo de un caso debe ser el mismo tipo de datos que la variable en el conmutador y debe ser un tipo de datos válido.
Cuando la variable que se enciende es igual a un caso, se ejecutarán las declaraciones que siguen a ese caso. No se necesita ningún descanso en la declaración del caso.
Una declaración de cambio puede tener un caso predeterminado opcional, que debe aparecer al final del cambio. El caso predeterminado se puede utilizar para realizar una tarea cuando ninguno de los casos es verdadero. No se necesita descanso en el caso predeterminado.

Ejemplo

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

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

type of x :<nil>

↰ Previous page