Dando continuidade nos nossos posts sobre comandos core da linguagem, nesse post vamos falar sobre o switch/case.

Esse comando é bem conhecido e existe em quase toda linguagem de programação. Se você nunca ouviu falar dele, tente imaginá-lo como uma forma mais curta de encadear um monte de if - else.

Uma diferença que vale ressaltar entre Go e as outras linguagens é que ao contrário das outras linguagens, o Go só executa o caso selecionado eliminando assim a necessidade de colocar um break.

Em sua forma mais básica, ele recebe um valor no inicio e depois checa se esse valor é igual algum dos casos definidos, e caso não seja, executa a caso padrão.

Para iniciar, vamos a um exemplo básico.

switch os := runtime.GOOS; os {
case "darwin":
    fmt.Println("MAC OS")
case "linux":
    fmt.Println("Linux")
default:
    fmt.Printf("%s \n", os)
}

Fazer a mesma checagem com if - else seria muito mais verboso e ruim para leitura.

As checagens sempre ocorrem de cima para baixo, e como dito antes, parando as comparações assim que um match é feito.

Um detalhe importante sobre os casos declarados, é que eles precisam ser do mesmo tipo que o valor que está sendo avaliado.

b := "1"
switch b {
case 1:
    fmt.Println("um")
case 2:
    fmt.Println("dois")
}

Um erro vai ocorrer no exemplo acima, pois estamos misturando dois tipos de dados diferentes.

Outro exemplo bacana, e que eu particularmente nunca vi em outra linguagem que já tenha trabalhado, é utilizar o switch/case sem passar um valor na cláusula switch.

t := time.Now()
switch {
case t.Hour() < 12:
    fmt.Println("Bom dia!")
case t.Hour() < 17:
    fmt.Println("Boa tarde.")
default:
    fmt.Println("Boa noite.")
}

Vamos comprar as mesmas validações escritas com if - else.

t := time.Now()
if t.Hour() < 12 {
    fmt.Println("Good morning!")
} else if t.Hour() < 17 {
    fmt.Println("Good afternoon.")
} else {
    fmt.Println("Good evening.")
}

Na minha opinião, além de escrever menos, quando comparado com if - else, a leitura fica muito mais limpa e fácil.

Para finalizar, vamos a um exemplo onde cada case é a chamada de uma outra função.

func parMenor10(v int) bool {
    if v%2 == 0 {
        return v < 10
    }

    return false
}

func parMaior10(v int) bool {
    if v%2 == 0 {
        return v > 10
    }

    return false
}

func main() {
    a := 4
    switch {
    case parMenor10(a):
        fmt.Println("par e menor que 10")
    case parMaior10(a):
        fmt.Println("par e maior que 10")
    default:
        fmt.Printf("número %d é ímpar\n", a)
    }
}

Deixem suas dúvidas nos comentários.

Até a próxima!

Faça parte da comunidade!

Receba os melhores conteúdos sobre Go, Kubernetes, arquitetura de software, Cloud e esteja sempre atualizado com as tendências e práticas do mercado.