Switch em Golang
Tags: go, beginners, tutorial
Published: 2020-05-27 20:03:35

Já ouviram falar do ``switch``?

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/hzf7z3xdzktn3ywl0wzh.png)
Não é esse tipo de switch...


![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/0oi14xmb0bdc3pazhmjj.png)
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."*

```golang

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.  

```golang

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.
```golang

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.
 
```golang

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. 

```golang

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.
```golang

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](https://youtu.be/WiGU_ZB-u0w).

**Até amanhã**. 
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/ho2fxtdu3o3j2gn1vpn6.gif)