Estruturas de Desvio Switch-Case em Golang

Introdução

No laboratório anterior, aprendemos sobre o uso das estruturas de desvio if-else. Neste laboratório, vamos explorar as instruções switch-case. Em comparação com o if-else, o switch é mais adequado para cenários que envolvem múltiplas condições.

Pontos de Conhecimento:

• Instruções switch-case
• Palavra-chave default
• Palavra-chave fallthrough

Sintaxe Básica

A sintaxe da instrução de desvio switch é semelhante à do if, pois ambas realizam julgamentos condicionais. A estrutura básica é a seguinte:

switch condition {
    case val1:
        // bloco de código
    case val2:
        // bloco de código
    ...
    default:
        // bloco de código
}

A condição pode ser qualquer tipo de expressão. Quando a condição corresponde ao valor de uma determinada instrução case, o bloco correspondente é executado e o programa sai da estrutura switch atual.

Os valores nas instruções case devem ser do mesmo tipo que a expressão da condição.

O programa avaliará as instruções case de cima para baixo e executará o primeiro case que coincidir. Após a execução, ele sairá do bloco switch.

A instrução default funciona de forma análoga ao else. Quando nenhum outro case corresponde à condição, o bloco default é executado.

Vamos analisar um exemplo de previsão do tempo. Crie um novo arquivo chamado switch.go e escreva o seguinte código:

cd ~/project
touch switch.go

package main

import (
    "fmt"
)

func main() {
    // Clima de hoje
    weather := "rainy"
    switch weather {
    case "snow":
        fmt.Println("Remember to wear a scarf today.🧣")
    case "rainy":
        fmt.Println("Remember to bring an umbrella today.🌂")
    default:
        fmt.Println("Today is sunny.☀")
    }
}

Execute o código:

go run switch.go

A saída será:

Remember to bring an umbrella today.🌂

Esta previsão do tempo exibirá resultados diferentes com base nas condições climáticas. Primeiro, definimos o clima de hoje como "rainy" (chuvoso). No desvio switch-case abaixo, definimos três condições. Quando neva, lembramos você de usar um cachecol; quando chove, lembramos do guarda-chuva; caso contrário, consideramos um dia ensolarado.

Múltiplos Valores em um Desvio

A instrução case também pode conter múltiplos valores, como mostrado abaixo:

switch condition {
    case val1, val2:
        // bloco de código
    ...
}

Atualizamos o programa de clima da seguinte forma:

package main

import (
    "fmt"
)

func main() {
    // Clima de hoje
    weather := "snow"
    switch weather {
    case "snow", "stormy":
        fmt.Println("Remember to wear a scarf today.🧣")
    case "haze", "sandstorm":
        fmt.Println("Remember to wear a mask today.😷")
    case "rainy":
        fmt.Println("Remember to bring an umbrella today.🌂")
    default:
        fmt.Println("Today is sunny.☀")
    }
}

go run switch.go

Após executar o código, a saída será:

Remember to wear a scarf today.🧣

Adicionamos mais algumas condições climáticas. Agora, o programa sugere o uso de máscara em caso de neblina ou tempestade de areia.

Instruções switch sem Variável Condicional

A variável condicional na instrução switch é um parâmetro opcional. Quando ela é omitida, o switch se comporta de maneira muito similar a uma estrutura if-else.

Reescrevemos o programa para exibir o dia da semana atual utilizando o switch sem uma variável condicional:

package main

import (
    "fmt"
    "time"
)

func main() {
    today := time.Now().Weekday()
    switch {
    case today == time.Monday:
        fmt.Println("Today is Monday.")
    case today == time.Tuesday:
        fmt.Println("Today is Tuesday.")
    case today == time.Wednesday:
        fmt.Println("Today is Wednesday.")
    case today == time.Thursday:
        fmt.Println("Today is Thursday.")
    case today == time.Friday:
        fmt.Println("Today is Friday.")
    case today == time.Saturday:
        fmt.Println("Today is Saturday.")
    default:
        fmt.Println("Today is Sunday.")
    }
}

go run switch.go

Após a execução, a saída será:

Today is Monday.

Neste programa, a variável condicional foi removida do cabeçalho do switch. Quando o programa é executado, ele verifica se as condições em cada case são verdadeiras. Quando uma condição é satisfeita, o código daquele desvio é executado e o programa sai do bloco switch.

Instrução fallthrough

Como mencionado anteriormente, após o programa executar um desvio case, ele sai automaticamente do switch atual.

Se você deseja continuar a execução para o próximo desvio logo após terminar um case, pode utilizar a instrução fallthrough.

Aqui estão as regras para o uso do fallthrough:

• Por padrão, após o switch encontrar uma correspondência e executar o case 10, ele não executará os desvios subsequentes. O fallthrough força a execução do próximo case.
• O fallthrough afeta apenas o próximo case imediato e não realiza a verificação da condição desse próximo case.
• O fallthrough não pode ser usado no último desvio do switch.

Vejamos um exemplo específico:

package main

import (
    "fmt"
)

func main() {
    n := 10
    switch n {
    case 10:
        fmt.Println(10)
        fallthrough
    case 3:
        fmt.Println(3)
    }
}

go run switch.go

Após a execução, a saída será:

10
3

O desvio switch imprime 10 após a correspondência com case 10 e, em seguida, imprime o valor do próximo case devido ao fallthrough.

Instrução de Inicialização no switch

Em Go, não apenas as instruções if possuem blocos de inicialização, mas o switch também. Você pode escrever uma instrução de inicialização antes da variável condicional, separando-as por um ponto e vírgula.

Desafio

Agora, você deve reescrever o programa da seção anterior movendo a instrução de inicialização para dentro da instrução switch.

Crie um novo arquivo chamado switch2.go. Escreva o código no arquivo switch2.go, modificando o exemplo anterior para incluir a inicialização no switch.

cd ~/project
touch switch2.go

O código da seção anterior era:

package main

import (
    "fmt"
)

func main() {
    n := 10
    switch n {
    case 10:
        fmt.Println(1)
        fallthrough
    case 3:
        fmt.Println(3)
    }
}

Requisitos:

• O arquivo switch2.go deve ser salvo no diretório ~/project.

Dica: Você pode consultar a seção de inicialização no laboratório de if-else para se basear na modificação.

Resumo

Neste laboratório, exploramos a instrução de desvio switch. Os pontos principais são:

• Quando um case coincide e é executado, o programa sai do bloco switch por padrão.
• Você pode usar fallthrough para continuar a execução no próximo case.
• O switch também suporta uma instrução de inicialização, separada da expressão condicional por um ponto e vírgula.