Declaración switch en el lenguaje Go

Go 语言条件语句Declaraciones condicionales en el lenguaje Go

La declaración switch se utiliza para ejecutar diferentes acciones según diferentes condiciones. Cada rama case es única y se prueba una a una de arriba a abajo hasta que coincide.

El proceso de ejecución de la declaración switch va de arriba a abajo hasta encontrar una coincidencia; después de la coincidencia no es necesario agregar break.

De forma predeterminada, cada case incluye una declaración break al final, por lo que después de una coincidencia exitosa no se ejecutan otros case. Si necesitamos ejecutar los case siguientes, podemos usarfallthrough 。

Sintaxis

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

switch var1 {
    case val1:
        ...
    case val2:
        ...
    default:
        ...
}

La variable var1 puede ser de cualquier tipo, mientras que val1 y val2 pueden ser cualquier valor del mismo tipo. El tipo no se limita a constantes o enteros, pero debe ser el mismo tipo; o expresiones cuyo resultado final sea del mismo tipo.

Puede probar múltiples valores que cumplan la condición a la vez, separándolos con comas, por ejemplo: case val1, val2, val3.

Diagrama de flujo:

Ejemplo

package main

import "fmt"

func main() {
   /* Definir variables locales */
   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("¡Excelente!\n" )    
      case grade == "B", grade == "C" :
         fmt.Printf("Bien\n" )      
      case grade == "D" :
         fmt.Printf("Aprobado\n" )      
      case grade == "F":
         fmt.Printf("Reprobado\n" )
      default:
         fmt.Printf("Mal\n" );
   }
   fmt.Printf("Tu calificación es %s\n", grade );      
}

El resultado de ejecutar el código anterior es:

优秀!
你的等级是 A

Type Switch

La declaración switch también se puede usar para type-switch y determinar el tipo real de variable almacenado en una variable de interfaz.

El formato de sintaxis de Type Switch es el siguiente:

switch x.(type){
    case type:
       statement(s);      
    case type:
       statement(s); 
    /* 你可以定义任意个数的case */
    default: /* 可选 */
       statement(s);
}

Ejemplo

package main

import "fmt"

func main() {
   var x interface{}
     
   switch i := x.(type) {
      case nil:  
         fmt.Printf("El tipo de x: %T",i)                
      case int:  
         fmt.Printf("x es de tipo int")                      
      case float64:
         fmt.Printf("x es de tipo float64")          
      case func(int) float64:
         fmt.Printf("x es de tipo func(int)")                      
      case bool, string:
         fmt.Printf("x es de tipo bool o string" )      
      default:
         fmt.Printf("Tipo desconocido")    
   }  
}

El resultado de ejecutar el código anterior es:

x 的类型 :<nil>

fallthrough

El uso de fallthrough fuerza la ejecución de la siguiente declaración case; fallthrough no evalúa si el resultado de la expresión del siguiente case es true.

Ejemplo

package main

import "fmt"

func main() {

    switch {
    case false:
            fmt.Println("1. La declaración de condición case es false")
            fallthrough
    case true:
            fmt.Println("2. La declaración de condición case es true")
            fallthrough
    case false:
            fmt.Println("3. La declaración de condición case es false")
            fallthrough
    case true:
            fmt.Println("4. La declaración de condición case es true")
    case false:
            fmt.Println("5. La declaración de condición case es false")
            fallthrough
    default:
            fmt.Println("6. case predeterminado")
    }
}

El resultado de ejecutar el código anterior es:

2、case 条件语句为 true
3、case 条件语句为 false
4、case 条件语句为 true

Del resultado de salida del código anterior se puede ver: switch comienza a ejecutarse desde el primer case cuya expresión de evaluación es true. Si el case tiene fallthrough, el programa continúa ejecutando el siguiente case, y no evalúa si la expresión del siguiente case es true.

Go 语言条件语句Declaraciones condicionales en el lenguaje Go

Otras extensiones