RALF LIMA - TREINAMENTOS EM TI

O que é a Estrutura de Repetição (For) no Go?

Olá, pessoal! Vamos dar continuidade ao nosso treinamento no canal Ralf Lima. Agora que já aprendemos a tomar decisões no código, vamos aprender a repetir instruções sem precisar reescrever as mesmas linhas várias vezes: estamos falando das estruturas de repetição, também conhecidas como loops.

Diferente de outras linguagens que possuem várias estruturas como while e do-while, o Go simplificou tudo e possui apenas o laço for. Ele é extremamente poderoso e consegue assumir diferentes papéis dependendo de como você o configura.

Como funciona o laço For tradicional?

O for tradicional é composto por três partes essenciais na sua linha de abertura, separadas por ponto e vírgula (;): a inicialização, a condição de parada e o modificador (incremento ou decremento).

Parte do Loop	O que ela faz?
`indice := 1;`	Inicialização: Cria uma variável contadora e define de onde a repetição vai começar.
`indice < 5;`	Condição de parada: Antes de cada repetição, o Go testa isso. O loop continua rodando enquanto for verdadeiro.
`indice++`	Modificador: Executado sempre no final de cada rodada para alterar o valor do contador.

Opções para Incrementar e Decrementar no Loop

Na hora de atualizar o seu contador ao final de cada rodada do loop, você pode escolher como quer avançar ou recuar. Veja as principais opções que podem ser aplicadas no modificador:

Símbolo / Expressão	Tipo de Operação	O que acontece com o contador?
`++`	Incremento unitário	Aumenta o valor da variável de 1 em 1 (ex: `indice++`).
`--`	Decremento unitário	Diminui o valor da variável de 1 em 1 (ex: `indice--`).
`+= x`	Incremento customizado	Soma um valor específico a cada rodada (ex: `indice += 2` pula de 2 em 2).
`-= x`	Decremento customizado	Subtrai um valor específico a cada rodada (ex: `indice -= 3` subtrai de 3 em 3).

Conteúdo Extra: Simulando um laço While

Como o Go não tem a palavra-chave while, nós usamos o próprio for para cumprir esse papel. Para simular um while, basta omitir a inicialização e o modificador da linha do loop, deixando **apenas a condição de parada**. O loop continuará rodando até que essa condição se torne falsa.

Conteúdo Extra: Percorrendo coleções com Range

Quando precisamos passar por todos os elementos de uma lista (como um vetor ou slice) sem nos preocuparmos em gerenciar contadores manualmente, o Go nos oferece a palavra-chave range. A cada rodada do laço, o range entrega automaticamente duas informações: o índice da posição atual e o valor guardado ali dentro.

Exemplos Práticos Completos

Veja abaixo o código estruturado demonstrando o loop tradicional, a simulação de um laço while e a leitura de uma lista de nomes com o range:

package main

import "fmt"

func main() {
    // 1. Estrutura de repetição tradicional
    fmt.Println("--- Loop Tradicional ---")
    for indice := 1; indice < 5; indice++ {
        fmt.Println(indice)
    }

    // 2. Simulando um laço "While"
    fmt.Println("\n--- Simulando While ---")
    contador := 1
    for contador <= 3 {
        fmt.Println("Contagem:", contador)
        contador++ // O incremento é feito dentro do bloco de código
    }

    // 3. Utilizando o Range para percorrer uma lista
    fmt.Println("\n--- Usando Range ---")
    nomes := []string{"Ralf", "Lima", "Go"}
    for indice, valor := range nomes {
        fmt.Printf("Posição: %d - Nome: %s\n", indice, valor)
    }
}