Sentencia Switch en Go

Golang, como la mayoría de los otros lenguajes de programación, tiene la declaración switch . La declaración switch en Golang  le permite evaluar una variable o expresión en múltiples casos y se utiliza a menudo cuando escribir múltiples declaraciones if-else hace que el código se vea feo y repetitivo.

En Go, la declaración switch es una declaración de ramificación multidireccional que dirige efectivamente la ejecución en función del valor (o tipo) de una expresión. Hay dos tipos principales de declaraciones switch en Go :

• Interruptor de expresión
• Interruptor de tipo

Por ejemplo:

package main
import "fmt"

func main() {
    day := 4
    switch day {
    case 1:
        fmt.Println("Monday")
    case 2:
        fmt.Println("Tuesday")
    case 3:
        fmt.Println("Wednesday")
    case 4:
        fmt.Println("Thursday")
    case 5:
        fmt.Println("Friday")
    default:
        fmt.Println("Invalid day")
    }
}

Sintaxis de la instrucción Switch en Golang

switch optstatement; optexpression {
case expression1:
    // Khối code
case expression2:                                                          # Expression Switch
    // Khối code
default:
    // Khối code
}

switch var := interfaceValue.(type) {
case type1:
    // Khối code
case type2:                                                                    # Type Switch
    // Khối code
default:
    // Khối code
}

Interruptor de expresión

Expression Switch evalúa una expresión y cambia a un caso según el valor de esa expresión. Si no se proporciona ninguna expresión, el valor predeterminado del conmutador es verdadero .

Sintaxis

switch optstatement; optexpression {
case expression1:
    // Khối code
case expression2:
    // Khối code
default:
    // Khối code
}

optstatement: Declaración opcional (por ejemplo, declaración de variable).
optexpression: expresión opcional (si se omite, el valor predeterminado es verdadero ).

Ejemplo con comando opcional

Aquí se introduce una declaración opcional que declara una variable de día . Luego, la instrucción switch evalúa el día según diferentes casos.

package main
import "fmt"
func main() {
    switch day := 4; day {
    case 1:
        fmt.Println("Monday")
    case 2:
        fmt.Println("Tuesday")
    case 3:
        fmt.Println("Wednesday")
    case 4:
        fmt.Println("Thursday")
    case 5:
        fmt.Println("Friday")
    default:
        fmt.Println("Invalid day")
    }
}

Resultado:

Thursday

Ejemplo con expresión opcional

Si no se especifica ninguna expresión, la declaración switch en Golang asumirá que la expresión es verdadera. Esto nos permite utilizar condiciones booleanas en declaraciones de caso.

package main
import "fmt"

func main() {
    day := 4

    switch {
    case day == 1:
        fmt.Println("Monday")
    case day == 4:
        fmt.Println("Thursday")
    case day > 5:
        fmt.Println("Weekend")
    default:
        fmt.Println("Invalid day")
    }
}

Resultado

Thursday

Interruptor de tipo

El cambio de tipo se utiliza para ramificar según el tipo de valor de una interfaz, en lugar de su valor. Esto es especialmente útil cuando se trata con variables de tipo desconocido.

Sintaxis

switch var := interfaceValue.(type) {
case type1:
    // Khối code
case type2:
    // Khối code
default:
    // Khối code
}

Por ejemplo:

Este ejemplo utiliza la misma variable de día pero envuelta en la interfaz {} para ilustrar la conversión de tipos.

package main
import "fmt"
func main() {
    var day interface{} = 4
    switch v := day.(type) {
    case int:
        switch v {
        case 1:
            fmt.Println("Monday")
        case 2:
            fmt.Println("Tuesday")
        case 3:
            fmt.Println("Wednesday")
        case 4:
            fmt.Println("Thursday")
        case 5:
            fmt.Println("Friday")
        default:
            fmt.Println("Invalid day")
        }
    default:
        fmt.Printf("Unknown type: %T\n", v)
    }
}

Resultado:

Thursday