Switch em Golang

Já ouviram falar do switch?

Não é esse tipo de switch...

Essa aí é a Taylor Swift 🤔

O switch, assim como o if, é um comando que pertence ao controle de fluxo condicional. Com ele conseguimos diminuir a quantidade de if/else encadeados.

Switch vem do verbo mudar. Vamos mudar algo, caso a condição seja verdadeira. Ele é muito utilizado em menus.

"Sr, digite um caso queira falar com a atendente. Digite dois, caso queira falar com o RH. Digite três, caso queira informações diversas."

op := 2

switch {
case op == 1:
    fmt.Println("Falar com a atendente")

case op == 2:
    fmt.Println("Falar com o RH")//Essa mensagem será exibida

case op == 3:
    fmt.Println("Informações diversas")

default:
    fmt.Println("Repetir opções")
}

Ele vai mudando de acordo com os casos. Caso a opção seja um, ele faz algo, caso a opção seja dois, ele irá fazer outra coisa, e assim por diante.

Iremos para o default se nenhum dos casos for utilizado.

op := 10

switch {
case op == 1:
    fmt.Println("Falar com a atendente")

case op == 2:
    fmt.Println("Falar com o RH")

case op == 3:
    fmt.Println("Informações diversas")

default:
    fmt.Println("Repetir opções")//Essa mensagem será exibida
}

Podemos utilizar a variável como statement. Facilitando ainda mais.

op := 10

switch op {//Estou colocando a variavel como statement
case 1:
    fmt.Println("Falar com a atendente")

case 2:
    fmt.Println("Falar com o RH")

case 3:
    fmt.Println("Informações diversas")

default:
    fmt.Println("Repetir opções")//Essa mensagem será exibida
}

Quando escolhemos fazer dessa maneira, não podemos utilizar condições que retornem true ou false.

Também podemos colocar mais de uma condição em cada case, utilizando os operadores lógicos.

num := 50

switch {
case (num >= 0) && (num <= 10):
    fmt.Println("num está entre 0 e 10  ")

case (num >= 10) && (num <= 30):
    fmt.Println("num está entre 11 e 30")

case(num >= 31) && (num == 50):
    fmt.Println("num está entre 31 e 50")//Essa mensagem será exibida

default:
    fmt.Println("num é maior que 50")
}

Se colocarmos a variável como statement, não poderemos fazer essas condições do exemplo.

fallthrough significar cair através. Quando colocamos ele em um dos casos, se ele for executado, o próximo caso também será. Ele cairá para o caso de baixo.

op := 1

switch op {
case 1:
    fmt.Println("Falar com a atendente")//Essa mensagem será exibida
    fallthrough

case 2:
    fmt.Println("Falar com o RH")//Essa também, pois utilizamos o fallthrough 

case 3:
    fmt.Println("Informações diversas")

default:
    fmt.Println("Repetir opções")
}

Também podemos fazer um switch de acordou com o tipo da variável.

var op interface{}//Declarando a variável como interface vazia

op := 10//Go vai deduzir que o tipo é int pelo valor atribuído

switch op.(type) {
case float64:
    fmt.Println("op é do tipo float64")

case bool:
    fmt.Println("op é do tipo bool")

case int:
    fmt.Println("op é do tipo int")//Essa mensagem será exibida

default:
    fmt.Println("nenhum dos casos")
}

var op interface{}. Quando declaramos uma variável com interface vazia quer dizer que ela poderá receber qualquer tipo (int, float, bool...). Normalmente já declaramos com um tipo certo: var op int, aqui ela so aceitaria tipos int.

Sabe porque a função de print aceita todos os tipos de valores? Ela tem a interface vazia, func Print(a ...interface{}) (n int, err error).

O post de hoje foi mais curto, mas cobrimos muito bem o switch.

Como sempre, se liga no curso.

Até amanhã.