Loop for em Golang
Tags: go, beginners, tutorial
Published: 2020-05-22 21:32:31

 Já vamos começar com uma notícia impactante, estão prontos?

**Em Go não tem loop while.**

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/r6typ53x0vwoirzpf9qc.jpg) 
*Também achei estranho, mas no final das contas ele não faz falta* 🤷🏾‍♀️.

Vamos rebobinar e começar por onde deveríamos ter começado, pelo começo.

Existem 3 tipos de fluxo de controle:
- **Sequencial**: É o fluxo padrão do código. Ele é lido de cima para baixo, de forma sequencial, sem interrupções.

- **Repetição**: É o fluxo que estudaremos hoje. Também é conhecido como iterativo ou loop. Ele irá repetir o mesmo código diversas vezes.

- **Condicional**: O fluxo condicional depende das condições que iremos criar. Ele só irá executar o código se a condição for verdadeira. 

```golang
for contador := 0; contador < valorMaximoDeVoltas; contador++{
    //Tudo que estiver aqui dentro será executado a cada volta do loop 
}

```
  
###**Fluxo de controle de repetição**

Como já mencionamos, o fluxo de controle de repetição irá quebrar o fluxo sequencial, que é o padrão. Ele será interrompido e um loop irá iniciar.

**Em Go, temos apenas o loop for**. Pode parecer insuficiente, mas não se engane, ele irá resolver bem os nossos problemas. 

- **``contador``**:

Ele irá contar as voltas do nosso loop. Podemos chamar ele de qualquer coisa, muitas pessoas chamam de "i".

Estamos declarando e inicializando o contador com o valor zero.

- **``valor máximo de voltas``**:

Normalmente quando fazemos um for, já sabemos a quantidade de loops que iremos precisar (5, 10, 20 voltas);

Esse número de voltas necessárias é o nosso valor máximo.

- **``contador < valorMaximoDeVoltas``**:

Isso aqui é uma condição, ela deve ser verdadeira para o loop acontecer. 

A lógica é a seguinte: Se o contador for menor que o valor máximo de voltas, então repita o loop mais uma vez.

- **``contador++``**:

Estamos realizando um pós incremento. O incremento só será realizado depois que a volta do loop for feita.

`` contador ++``  é a mesma coisa que  ``contador = contador + 1``. 


**O incremento é importante**, pois sem ele irá acontecer um **loop infinito**. Não teremos mais controle sob quantas voltas o loop deu, o contador nunca irá ficar maior que o valor máximo de voltar, então o loop nunca parará de rodar.
*Em alguns casos essa pode ser a funcionalidade que queremos, mas na maioria das vezes não é.* 

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/qz48xrp0u70593h1ofs1.jpg)


```golang
for i := 0; i <= 10; i++{
   fmt.Printf("%v -", i)
}

//Resultado: 0 - 1 - 2 - 3 - 4 - 5 - 6 - 7 - 8 - 9 - 10
```
*Esse é um exemplo básico*.

**Também podemos ter loops dentro de loops, são loops aninhados**.

```golang
for horas := 1; horas <= 2; horas++{
   fmt.Printf("***Hora: %v", horas)

   for minutos := 1; minutos <= 60; minutos{
       fmt.Printf("\t%v\t", minutos)
   }

   fmt.Println(" ")
}

/*Resultado: Vamos mostrar cada minutos que existe em duas horas
*** Hora: 1
        1       2       3       4       5       6       7       8       9       10      11      12      13      14      15      16      17      18      19      20      21      22    
23      24      25      26      27      28      29      30      31      32      33      34      35      36      37      38      39      40      41      42      43      44      45    
46      47      48      49      50      51      52      53      54      55      56      57      58      59      60
*** Hora: 2
        1       2       3       4       5       6       7       8       9       10      11      12      13      14      15      16      17      18      19      20      21      22    
23      24      25      26      27      28      29      30      31      32      33      34      35      36      37      38      39      40      41      42      43      44      45    
46      47      48      49      50      51      52      53      54      55      56      57      58      59      60
*/
```

``horas`` e ``minutos`` são nossos contadores, iniciamos eles do 1 pois não existe minuto 0 e não queremos começar com a hora 0. 
 
O loop de horas é o maior, ele engloba o loop de minutos. Já o loop de minutos está contido no loop de horas, ele é menor. *O que isso quer dizer?* Quer dizer que o loop de minutos irá rodar mais vezes que o loop de horas. 

**Essa sempre será a lógica, quando mais interno um loop é, mais ele irá rodar**.

Para um loop de horas (1 hora), o loop de minutos irá girar 60 vezes, pois temos 60 minutos em uma hora. 

Podemos aninhar quantos loops quisermos. Podemos até colocar um loop de segundo dentro do loop de minutos. O loop de segundos irá girar 60 vezes para cada loop do minuto, e girará 3600 vezes para um loop da hora. 

**Tentem fazer um loop que mostre todos os dias de 3 meses, vamos considerar que cada mês tem exatamente 30 dias**. 

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/394z6v35hy4dfeoi60du.jpg)

```golang

for mes := 1; mes <= 3; mes++{
    fmt.Println("*** mês:", mes)

    for dia := 1; dia <= 30; dia++{
        fmt.Printf("%v   ", dia)
    }
    
    fmt.Println(" ")
}

/*Resultado:
*** mês: 1
1  2  3  4  5  6  7  8  9  10  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25  26  
27  28  29  30
*** mês: 2
1  2  3  4  5  6  7  8  9  10  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25  26  
27  28  29  30
*** mês: 3
1  2  3  4  5  6  7  8  9  10  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25  26  
27  28  29  30
*/
```
*Podemos fazer isso para todos os meses do ano*

Se você quiser simular um ``while``, também é possível.
```golang
i := 0

for i < 10 {
    fmt.Println(i)
    i++
}
```

Agora conheçam um loop infinito:
```golang
for  {
    fmt.Println("loop infinito")
}
```
Esse loop é infinito de propósito, **não colocamos uma condição para ele parar de girar**. Quando fazemos um loop assim, sua funcionalidade demanda algo que esteja rodando constantemente. Mas as vezes podemos esquecer de algum incremento ou outro elemento, então criaremos um loop infinito por falha.   

Temos outro tipo de ``for``, o ``for range``, mas vamos falar dele amanhã. Podemos fazer a maioria das coisas com o ``for`` normal, mas as vezes o ``for range`` pode ser a melhor escolha. Ele é muito utilizado com slices e strings.

**Continue** e **break** 

São funcionalidades muito utilizadas no loop. O ``break`` é para interromper um loop antes dele completar suas voltas necessárias. Já o ``continue`` interrompe apenas uma volta, ele pula aquela volta, mas não interrompe o loop completo. 

Exemplo: 

```golang
for i := 0; i < 20; i++{
    if(i == 5){ //Se i for igual a 5, interrompa a volta dele
        continue
    }

    if (i == 16){ //Se i for igual a 16, quebre o loop
        break
    }

    fmt.Println(i)
}

//Resultado: 1 2 3 4 6 7 8 9 10 11 12 13 14 15 
```
O número 5 não será exibido, pois a volta dele foi interrompida pelo ``continue``, já o 16 não será mostrado pois o loop foi interrompido pelo ``break``.

*Se você não entendeu esse tal de ``if(i == 5)`` e ``if (i == 16)``, não se preocupe. O ``if`` faz parte do fluxo de controle condicional, é assunto para outro dia.*

Lembrando, estou aqui para **documentar meus estudos**. Se quiserem estudar também, assistam esse **[curso](https://youtu.be/WiGU_ZB-u0w)** que é sucesso 🤙🏾.  

**Por hoje é só, fiquem bem e se cuidem. Até amanhã**.

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/qkdrieb3j9foldyrsp4w.png)