Loop por meio de dados com para expressões

Concluído

Outro fluxo de controle comum é um loop. O Go usa apenas uma construção de looping, que é um loop for. Mas os loops podem ser representados de mais de uma maneira. Nesta parte, você conhecerá os padrões de loop compatíveis com o Go.

Sintaxe básica de loop for

Assim como as instruções if e switch, as expressões loop for não exigem parênteses. Já as chaves “{ }”são necessárias.

Pontos-e-vírgulas (;) separam os três componentes dos loops for:

• Uma instrução inicial que é executada antes da primeira iteração (opcional).
• Uma expressão de condição que é avaliada antes de cada iteração. O loop para quando essa condição é false.
• Uma repetição que é executada no final de cada iteração (opcional).

Como se pode ver, o loop for no Go é semelhante ao loop for em linguagens de programação como C, Java e C#.

Em sua forma mais simples, um loop for tem esta aparência:

func main() {
    sum := 0
    for i := 1; i <= 100; i++ {
        sum += i
    }
    fmt.Println("sum of 1..100 is", sum)
}

Vamos ver de que outras maneiras se podem escrever loops no Go.

Instruções prévias e posteriores vazias

Em algumas linguagens de programação, a palavra-chave while é usada para escrever padrões de loop onde apenas a expressão de condição é necessária. O Go não tem palavras-chave while. No entanto, é possível usar um loop for como alternativa e aproveitar o fato de que o Go torna as pré-declarações e pós-declarações opcionais.

Use o seguinte trecho de código para confirmar que o loop for pode ser usado sem as instruções prévias e posteriores.

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    var num int64
    rand.Seed(time.Now().Unix())
    for num != 5 {
        num = rand.Int63n(15)
        fmt.Println(num)
    }
}

Desde que a variável num contenha um valor diferente de 5, o programa imprimirá um número aleatório.

Loops infinitos e instruções break

Outro padrão de loop que pode ser escrito no Go é o loop infinito. Nesse caso, não se escreve uma expressão de condição nem instruções prévias ou posteriores. Em vez disso, escreve-se a saída do loop. Caso contrário, a lógica nunca será encerrada. Para fazer com que a lógica saia de um loop, use a palavra-chave break.

Para escrever um loop infinito adequado, siga a palavra-chave for de chaves, desta forma:

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    var num int32
    sec := time.Now().Unix()
    rand.Seed(sec)

    for {
        fmt.Print("Writing inside the loop...")
        if num = rand.Int31n(10); num == 5 {
            fmt.Println("finish!")
            break
        }
        fmt.Println(num)
    }
}

Toda vez que você executar esse código, obterá uma saída diferente.

Instruções continue

No Go, é possível usar a palavra-chave continue para ignorar a iteração atual de um loop. Essa palavra-chave pode ser usada, por exemplo, para executar uma validação antes de o loop continuar. Ou use-a quando estiver escrevendo um loop infinito e precisar aguardar que um recurso fique disponível.

Este exemplo usa o módulo continue:

package main

import "fmt"

func main() {
    sum := 0
    for num := 1; num <= 100; num++ {
        if num%5 == 0 {
            continue
        }
        sum += num
    }
    fmt.Println("The sum of 1 to 100, but excluding numbers divisible by 5, is", sum)
}

Este exemplo tem um loop for que itera de 1 a 100, adicionando o número atual à soma em cada iteração. Todo número divisível por 5 é ignorado na iteração atual do loop e não é adicionado à soma.