Go LangLoopsLoop em GoEstrutura de repetição GoAprender Go

Loop em Go: guia para dominar a repetição na linguagem

Rocketseat

Rocketseat

5 min de leitura
golang

Navegação Rápida:

Fala, dev! Se você está começando sua jornada em Go, já deve ter percebido que repetir tarefas é uma parte constante do nosso dia a dia. Seja para listar todos os usuários de um sistema ou processar itens de um carrinho de compras, a repetição é um requisito. E em programação, ela é constantemente usada!
Os loops permitem que a gente execute um bloco de código várias vezes, de forma automática e controlada. É o que nos poupa de escrever a mesma linha de código centenas de vezes.
A boa notícia? Go simplifica isso de uma forma genial.
📄
Se você ainda está se familiarizando com o básico da linguagem, confira nosso guia de primeiros passos com Go para não ficar com nenhuma dúvida!
Vamos juntos desvendar como o loop em Go pode impulsionar seus projetos. Bora codar?

Por que Go usa apenas o loop for? A beleza da simplicidade

Diferente de outras linguagens que oferecem while, do-while, e for, Go adota uma filosofia minimalista e poderosa: existe apenas uma estrutura de repetição, o for. Mas não se engane, essa única estrutura é tão versátil que consegue cobrir todos os cenários que você possa imaginar, de uma forma limpa e clara.
Essa decisão de design elimina a confusão sobre qual loop usar em cada situação, permitindo que você foque no que realmente importa: a lógica do seu código.
📄
Quer entender melhor por que Go tomou decisões tão diferentes de outras linguagens? Leia este artigo sobre a criação do Go e descubra a mentalidade por trás da simplicidade da linguagem.

A estrutura clássica: seu primeiro loop em Go

A forma mais tradicional do loop for em Go vai ser familiar se você já teve contato com outras linguagens como Java ou JavaScript.

Entendendo as três partes: inicialização, condição e pós-execução

A estrutura é dividida em três componentes, separados por ponto e vírgula:
  1. inicialização: executada apenas uma vez, no início do loop. É aqui que geralmente declaramos uma variável de controle (um contador).
  1. condição: verificada antes de cada iteração. Se for true, o corpo do loop é executado. Se for false, o loop termina.
  1. pós-execução: executada ao final de cada iteração. É aqui que geralmente incrementamos nosso contador.
Vamos ver na prática, criando um loop que imprime os números de 0 a 4:
package main

import "fmt"

func main() {
    //   1. inicialização | 2. condição | 3. pós-execução
    for i := 0; i < 5; i++ {
        fmt.Println("O valor de i é:", i)
    }
}
Ao rodar este código, a instrução fmt.Println será executada cinco vezes, com i variando de 0 a 4. Simples, né?

Simulando um while em Go com for

E se você precisar de um loop que rode enquanto uma condição for verdadeira, como um while? Em Go, basta omitir a inicialização e a pós-execução, deixando apenas a condição.
package main

import "fmt"

func main() {
    // Começamos o contador fora do loop
    contador := 0

    // O loop continua enquanto 'contador' for menor que 10
    for contador < 10 {
        fmt.Println("Contagem:", contador)
        // Não se esqueça de incrementar o contador para não criar um loop infinito!
        contador++
    }
}
Esse código vai imprimir a contagem de 0 a 9. É a prova de como o for de Go é flexível!

Loops infinitos e o poder do break

Às vezes, queremos que um programa rode para sempre, como um servidor web que precisa estar sempre escutando por novas conexões. Para isso, podemos criar um loop infinito simplesmente omitindo todas as partes da declaração for.
package main

import "fmt"
import "time"

func main() {
    for {
        fmt.Println("Servidor rodando... processando requisições.")
        // Adicionamos um sleep para não sobrecarregar o processador ao rodar localmente
        time.Sleep(2 * time.Second) 
    }
}
Mas como paramos um loop desses de forma controlada? Com a instrução break. O break encerra o loop imediatamente, não importa a condição.
Vamos ajustar o exemplo para parar depois de algumas execuções:
package main

import "fmt"

func main() {
    count := 0
    for {
        fmt.Println("Executando a tarefa...")
        count++

        // Quando o contador chegar a 5, o 'break' é acionado.
        if count >= 5 {
            fmt.Println("Tarefa concluída. Saindo do loop.")
            break
        }
    }
}

A forma mais idiomática: iterando com for range

O verdadeiro poder e a forma mais comum de usar loop em Go no dia a dia é com a cláusula range. Ela foi feita para percorrer coleções de dados como slices, arrays, strings, maps e channels.
O range retorna duas informações a cada iteração: o índice do elemento e uma cópia do valor do elemento.
Vamos iterar sobre um slice de tecnologias que usamos aqui na Rocketseat:
package main

import "fmt"

func main() {
    tecnologias := []string{"Go", "Node.js", "React", "Python"}

    for indice, tecnologia := range tecnologias {
        fmt.Printf("No índice %d, temos a tecnologia: %s\n", indice, tecnologia)
    }
}
Se você não precisar do índice, pode simplesmente ignorá-lo usando o "identificador em branco" (_):
// ...
for _, tecnologia := range tecnologias {
    fmt.Println("Tecnologia:", tecnologia)
}
📄
Para entender ainda mais como iterar sobre estruturas como arrays e slices, este artigo sobre arrays em Go vai te ajudar a dominar essa parte importante da linguagem.

Pulando etapas com o continue

Já vimos que o break sai do loop. Mas e se quisermos apenas pular a iteração atual e ir para a próxima? Para isso, usamos o continue.
Imagine que queremos imprimir uma lista de números, mas pular o número 3.
package main

import "fmt"

func main() {
    for i := 0; i < 5; i++ {
        // Se 'i' for igual a 3, pula o resto do código desta iteração
        if i == 3 {
            fmt.Println("Ops, pulando o 3!")
            continue
        }
        fmt.Println("Imprimindo o número:", i)
    }
}
O resultado será a impressão dos números 0, 1, 2 e 4. O número 3 foi "pulado"!

Desafio prático: organizando cursos da Rocketseat

Para fechar, que tal um desafio? Imagine que você precisa exibir uma lista de cursos da Rocketseat e seus respectivos módulos. Temos uma estrutura de dados com essa informação e, para exibi-la de forma organizada, vamos usar loops aninhados (um loop dentro do outro).
package main

import "fmt"

func main() {
    // Cada item da lista é um slice de strings: [Nome do Curso, Módulo 1, Módulo 2, ...]
    cursos := [][]string{
        {"Formação em Go", "Fundamentos de Go", "Construindo APIs"},
        {"Formação em React", "Fundamentos do React", "Hooks e Context API"},
    }

    fmt.Println("--- Trilhas de Estudo Rocketseat ---")
    // O primeiro loop percorre a lista de cursos
    for _, curso := range cursos {
        nomeDoCurso := curso[0]
        modulos := curso[1:] // Pega todos os elementos a partir do segundo

        fmt.Printf("\nCurso: %s\n", nomeDoCurso)
        
        // O segundo loop (aninhado) percorre os módulos do curso atual
        for j, modulo := range modulos {
            fmt.Printf("  Módulo %d: %s\n", j+1, modulo)
        }
    }
}
Com este código, você consegue exibir a estrutura de forma clara. Esse é um exemplo clássico de como loops aninhados nos ajudam a lidar com dados mais complexos no dia a dia. Faz sentido?
📄
Curtiu o desafio? Temos uma seleção de problemas clássicos de lógica resolvidos com Go para você testar seus conhecimentos e evoluir ainda mais.

Quando usar cada variação do loop em Go?

Variação do for
Quando usar
Exemplo
Clássico
Quando você precisa de um contador e sabe o número de iterações.
for i := 0; i < 10; i++
Condicional (while)
Quando o loop depende de uma condição que pode mudar.
for condicao == true
Infinito
Para tarefas que precisam rodar continuamente (servidores, listeners).
for {}
range
Sempre que for percorrer slices, arrays, maps ou strings.
for i, v := range minhaLista
📄
Agora que você domina loops, o próximo passo é entender como tomar decisões com o código. Aprenda a usar if, else e switch de forma eficaz em tomando decisões com Go.

Sua jornada com Go está só começando!

Ufa! Vimos como o for em Go é uma ferramenta simples, mas incrivelmente poderosa. Dominar suas variações é um passo gigante na sua jornada para se tornar uma pessoa desenvolvedora de alta performance em Go.
E se você quer um caminho estruturado para não só aprender Go, mas também construir projetos reais e ganhar confiança, a Rocketseat está aqui para te impulsionar.
💜
Dê seus primeiros passos com nosso curso gratuito! No Curso Introdutório de Go, você vai aprender os conceitos básicos da linguagem, desde a instalação e configuração do ambiente até a criação de estruturas de dados e o básico sobre concorrência. É o ponto de partida perfeito, sem gastar nada! Comece a aprender Go de graça agora mesmo!
📄
Quer ver um panorama completo do que você pode construir com Go em 2025? Confira nosso artigo especial: Aprenda Go: O que esperar da linguagem em 2025.
🚀
Pronto para o próximo nível? Domine Go de verdade! Na nossa Formação em Go, você vai muito além. Aprenda a construir aplicações robustas e de alta performance, com projetos práticos que vão direto para o seu portfólio. Desenvolva APIs REST, entenda as melhores práticas do mercado e saia com uma certificação que vai brilhar os olhos dos recrutadores. Conheça a Formação em Go e impulsione sua carreira!
Artigos_

Explore conteúdos relacionados

Descubra mais artigos que complementam seu aprendizado e expandem seu conhecimento.