Sentencia Switch del lenguaje Go

La declaración switch es una declaración de ramificación múltiple. Proporciona un método efectivo para transferir la ejecución a diferentes partes del código en función del valor de la expresión (también conocida como case). El lenguaje Go admite dos tipos de declaraciones switch:

1. La expresión switch

2. Switch de tipo

La expresión switch

La expresión switch es similar a C, C ++La declaración de switch en Java. Proporciona un método simple para asignar la ejecución a diferentes partes del código según el valor de la expresión.

Sintaxis:

switch optstatement; optexpression {
　　　　case expresión1: Statement..
　　　　case expresión2: Statement..
　　　　...
　　　　default: Statement..
}

Consejo importante:

• Las declaraciones optstatement y optexpression en la expresión switch son declaraciones de opción.

• Si existenoptstatementyoptpressionEntonces, entre ellos se necesita usar punto y coma (;).

• Si la declaración de switch no contiene ninguna expresión, el compilador asume que esta expresión es verdadera.

• La declaración de opción, es decir, optstatement, contiene declaraciones simples, como declaraciones de variables, declaraciones de incrementos o asignaciones o llamadas a funciones, etc.

• Si la declaración de opción contiene variables, el alcance de estas variables está limitado a la declaración de switch.

• En la declaración de switch, las declaraciones de caso y defecto no contienen declaraciones de break. Pero si su programa lo requiere, puede usar declaraciones de break y fallthrough.

• La declaración de defecto (default) en la declaración de switch es opcional.

• Si un caso puede contener varios valores y estos valores están separados por comas (,).

• Si un caso no contiene ninguna expresión, el compilador asume que esta expresión es verdadera.

Ejemplo de obtener el día de la semana de un número específico:

package main
import "fmt"
func main() {
　　　　//　Las declaraciones de switch utilizan dos tipos de declaraciones, como opciones, día :=4　y expresiones como: día
　　　　switch día :=　4; día {
　　　　case　1:
　　　　　　　　fmt.Println("Lunes")
　　　　case　2:
　　　　　　　　fmt.Println("Martes")
　　　　case　3:
　　　　　　　　fmt.Println("Miércoles")
　　　　case　4:
　　　　　　　　fmt.Println("Jueves")
　　　　case　5:
　　　　　　　　fmt.Println("Viernes")
　　　　case　6:
　　　　　　　　fmt.Println("Sábado")
　　　　case　7:
　　　　　　　　fmt.Println("Domingo")
　　　　default:
　　　　　　　　fmt.Println("Invalid")
　　　　}
}

Salida:

Jueves

Ejemplo de declaración de switch sin opciones ni expresiones:

package main　
　　
import "fmt"
　　
func main() {　
　　　　var value int =　2　
　　　　　　
　　　　　　//　La declaración de switch sin opciones ni expresiones
　　　switch {　
　　　　　　　case value ==　1:　
　　　　　　　fmt.Println("Hello")　
　　　　　　　case value ==　2:　
　　　　　　　fmt.Println("Bonjour")　
　　　　　　　case value ==　3:　
　　　　　　　fmt.Println("Namstay")　
　　　　　　　default:　　
　　　　　　　fmt.Println("Invalid")　
　　　}　
　　
}

Salida:

Bonjour

El siguiente es un caso de switch sin语句 por defecto, múltiples valores en la declaración case:

package main
import "fmt"
func main() {
　　　　var value string = "five"
　　　　//Sentencia switch sin cláusula de default, múltiples valores en la cláusula case
　　　　switch value {
　　　　case "one":
　　　　　　　　fmt.Println("C#")
　　　　case "two", "three":
　　　　　　　　fmt.Println("Go")
　　　　case "four", "five", "six":
　　　　　　　　fmt.Println("Java")
　　　　}
}

Salida:

Java

Switch de tipo

Cuando desee comparar tipos, utilice el tipo switch. En este switch, los casos contienen tipos que deben compararse con los tipos que aparecen en la expresión de switch.

Sintaxis:

switch optstatement; expressione de tipo switch{
　　　　case typelist　1: Statement..
　　　　case typelist　2: Statement..
　　　　...
　　　　default: Statement..
}

Consejo importante:

• Cláusula opcional, es decir, optstatement, que es similar a la expresión de switch.

• Si un caso puede contener varios valores y estos valores están separados por comas (,).

• En la sentencia de tipo switch, las cláusulas case y default no contienen ninguna cláusula break. Sin embargo, si el programa lo requiere, se pueden usar las cláusulas break y fallthrough.

• En la sentencia de tipo switch, la cláusula de default es opcional.

• expressione de tipo switches una expresión que resulta en un tipo.

• Si se asigna una expresión utilizando el operador de asignación en una expresión de tipo switch, el tipo de la variable depende del tipo especificado en la cláusula case. Si la cláusula case contiene dos o más tipos, el tipo de la variable es el tipo en el que se crea la variable en la expresión de tipo switch.

package main
import "fmt"
func main() {
　　　　var value interface{}
　　　　switch q := value.(type) {
　　　　case bool:
　　　　　　　　fmt.Println("El valor es booleano")
　　　　case float64:
　　　　　　　　fmt.Println("El valor es float")64tipo)
　　　　case int:
　　　　　　　　fmt.Println("El valor es de tipo int")
　　　　default:
　　　　　　　　fmt.Printf("El tipo de valor es: %T", q)
　　　　}
}

Salida:

El tipo de valor es: <nil>