Golang básico - Controle de Fluxo
Tags: go, tutorial, iniciante, portugues
Published: 2022-05-28 17:48:50

---
title: Golang básico - Controle de Fluxo
published: true
description: 
tags: #go #golang #tutorial #iniciante #portugues
cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/wsrivp5deyklmxxxa6ok.jpeg
series: Golang básico
---
> Esse post faz parte de uma série onde pretendo compartilhar o básico essencial para desenvolver com GoLang.

No primeiro post, sobre variáveis, eu mencionei que sistemas funcionam com entrada -> processamento -> saída. Nesse post vamos entender isso um pouco melhor.

## Algoritmos

Toda tarefa executada por um computador é resultado de um algoritmo. Uma definição simples de entender é de que algoritmos são receitas com o passo a passo do que o computador deve fazer.
Diferente de uma receita de comida, para o computador você precisa dar todos os detalhes.

### Etapas de um algoritmo

Todo algoritmo pode ser dividido em algumas etapas simples:
* entrada: leitura de dados que são armazenados em variáveis.
* sequência: ordem em que as etapas devem acontecer.
* condições: controle de fluxo :eyes:
* repetições: controle de fluxo :eyes:
* saída: a resposta do problema que o algoritmo está resolvendo.

Não parece tão complicado, não é? Entendendo essas etapas você consegue entender qualquer software, não importa a linguagem, paradigma ou framework. Todos funcionam dessa maneira.
A parte boa, você provavelmente já está fera em **`entrada`** pois leu o post sobre variáveis. A parte de sequência é bem auto explicativa e vai ficar bem fácil de visualizar com um exemplo. Então vamos ao que interessa, controles de fluxos em Go.

## Controle de Fluxo
### Condições IF, ELSE, SWITCH

Condições com IF em go são muito parecidas com a do C e suas similares, tendo alguns detalhes.

```go
if condicao {
	fmt.Println("faz algo genial")
}
```
Temos 3 coisas: 
* o uso da palavra reservada **`if`**.
* uma condição (sem parênteses) podendo ser uma variável booleana ou uma expressão lógica.
* bloco dentro de chaves `{...}`, que em Go é obrigatório.

```go
// você também pode utilizar else...if 
if condicao {
	fmt.Println("faz algo genial")
} else if outra_condicao {
        fmt.Println("faz algo genial ao contrario")
} else {
        fmt.Println("desiste")
}
```

### Expressão lógica

Se esse é um dos seus primeiros contatos com programação, esse material provavelmente não será o suficiente, mas eu espero que possa ser um incentivo para que você busque mais conhecimento, disclaimer feito. Vamos lá.

Expressões lógicas podem ter `operadores de comparação` e/ou `operadores lógicos`.

#### Operadores de comparação
```
==    igual
!=    diferente
<     menor
<=    menor ou igual
>     maior
>=    maior ou igual
```
#### Operadores lógicos
```
&&    conjunção (AND)
||    disjunção (OR)
!     negação
```
#### Exemplo simples
```go
// utilizando operador de comparação + operador lógico
if produto.status == publicado && produto.cor != azul {
	fmt.Println("Produto selecionado")
}
```

E é basicamente dessa forma que programamos tomadas de decisões dentro do código. Mais uma vez, se esse é um dos seus primeiros contatos eu vou te sugerir o seguinte, da uma olhada em:
[Álgebra Booleana](https://pt.wikipedia.org/wiki/%C3%81lgebra_booliana)
[Tabela Verdade](https://pt.wikipedia.org/wiki/Tabela-verdade)

Não se assuste pelos nomes, são tópicos que você precisa exercitar e se tiver oportunidade faça um curso de lógica de programação.

### SWITCH

Switch em Go são bastante flexiveis, podendo ser usados de algumas maneiras, a maneira mais comum é criar condições para conjunto de tipos, novamente usando nosso produto como exemplo:

```go
// bastante comum de ser usado com tipos enumerados
switch produto.cor {
case vermelho:
	fmt.Println("Desconto 20% no vermelho")
case verde:
	fmt.Println("Desconto 10% no verde")
case azul:
	fmt.Println("Desconto 5% no azul")
}
```

Outra sintaxe possível e também incentivada é utilizar o switch vazio e os cases com expressões lógicas, é uma maneira idiomática de evitar series grandes de if..else..if:

```go
switch {
case meuStatus != rascunho && meuStatus != deletado:
	fmt.Println("Faz algo com produtos diferentes de rascunhos")
case meuStatus == publicado || meuStatus != congelado:
	fmt.Println("Faz algo com publicados")
case meuStatus == congelado:
	fmt.Println("Faz algo com congelados")
}
```
Para mais detalhes veja a documentação:
[Switch_statements](https://go.dev/ref/spec#Switch_statements)
[Effective Go Switch](https://go.dev/doc/effective_go#switch)

### Repetições For

Em Go a única palavra reservada para laços de repetições é o **`for`**.
Vamos a alguns exemplos rápidos:

```go
// loop infinito
for {
	fmt.Println("rodando... pra sempre")
	time.Sleep(time.Second * 1)
}
```

```go
// repete enquanto a condição for verdadeira
for meuStatus != publicado {
	fmt.Println("rodando... pra sempre")
	time.Sleep(time.Second * 1)
        //... faz algum processamento que atualize meuStatus
}
```

```go
// for incremental
// além a condição tem operação de inicialização: i := 0
// e uma pós operação para incrementar a variável
for i := 0; i < 10; i++ {
	fmt.Println(i)
}
```

### Palavra reservada `range`
Além dos exemplos acima, quando estiver iterando com slices e maps, é possível utilizar `range` para ambos:

```go
personagens := []string{"Kurono", "Guts", "Eren"}
// range te devolve duas variáveis, o índice e o valor
for i, valor := range personagens {
	fmt.Println(i, valor)
}
```
Exatamente a mesma sintaxe para maps
```go
personagemAnime := map[string]string{
	"Eren":   "Attack on Titan",
	"Guts":   "Berserk",
	"Kurono": "Gantz",
}
for chave, valor := range personagemAnime {
	fmt.Println(chave, valor)
}
```
Um detalhe importante, nem sempre queremos trabalhar com o índice do array ou a chave do mapa, é bem comum a gente só iterar pelos valores, nesse caso precisamos usar o caracter `_`:
```go
personagens := []string{"Kurono", "Guts", "Eren"}
for _, valor := range personagens {
	fmt.Println(valor)
}
```

## Resumo

Nesse post você viu como fazer o controle de fluxo de um código em Go e a estrutura de um algoritmo. E por mais que possa soar exagerado, é sério que isso pode te tornar capaz de ler qualquer código.
Mas veja, para fazermos uma analogia, é como se eu tivesse te apresentado as notas musicais em um instrumento especifico. Você agora é capaz de ler partituras e com exercício pode começar a tocar sua versão.

* algoritmos são receitas
* etapas de um algoritmo: entrada, sequência, condições, repetições, saída
* estude mais sobre expressões lógicas
* estude tabela verdade e algebra booleana