Instrução Switch em Go

Golang como a maioria das outras linguagens de programação tem a instrução switch . A instrução switch em Golang  permite que você avalie uma variável ou expressão em vários casos e é frequentemente usada ao escrever várias instruções if-else, o que faz com que o código pareça feio e repetitivo.

Em Go, a instrução switch é uma instrução de ramificação multidirecional que efetivamente direciona a execução com base no valor (ou tipo) de uma expressão. Existem dois tipos principais de instruções switch em Go :

• Troca de expressão
• Interruptor de tipo

Por exemplo:

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

Sintaxe da instrução Switch em 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
}

Troca de expressão

O Expression Switch avalia uma expressão e alterna para um caso com base no valor dessa expressão. Se nenhuma expressão for fornecida, o switch assumirá o valor padrão true .

Sintaxe

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

optstatement: Declaração opcional (por exemplo, declaração de variável).
optexpression: Expressão opcional (se omitida, o padrão é true ).

Exemplo com comando opcional

Aqui introduz uma declaração opcional que declara uma variável de dia . A instrução switch então avalia o dia de acordo com 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

Exemplo com expressão opcional

Se nenhuma expressão for especificada, a instrução switch em Golang assumirá que a expressão é verdadeira. Isso nos permite usar condições booleanas em instruções case.

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

O Type Switch é usado para ramificar o tipo de um valor de interface, em vez do seu valor. Isto é especialmente útil ao lidar com variáveis ​​de tipo desconhecido.

Sintaxe

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

Por exemplo:

Este exemplo usa a mesma variável de dia , mas encapsulada em interface{} para ilustrar a conversão de tipo.

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