Iteração por intervalo de números em Go: 3 abordagens poderosas

Por que a pergunta "Is there a way to iterate over a range of integers?" é tão popular?

Se você já migrou do Python para o Go, certamente sente falta do elegante for i in range(10):. No Python, isso funciona perfeitamente. No Go... as coisas são um pouco diferentes. A pergunta no Stack Overflow com esse título acumulou milhares de visualizações — e não por acaso. Desenvolvedores acostumados com abstrações de alto nível muitas vezes se perdem ao encontrar a sintaxe minimalista do Go.

Neste artigo, vamos explorar todas as formas de iterar sobre um intervalo de números inteiros em Go: desde o clássico for até utilitários modernos. Você descobrirá qual abordagem escolher para máximo desempenho e qual para legibilidade do código. Vamos nessa!

Método nº 1: O clássico for (Go idiomático)

Go é uma linguagem pragmática. Não possui um range nativo para números, mas tem um for poderoso. A maneira mais simples e eficiente é usar o loop de três componentes:

package main\n\nimport "fmt"\n\nfunc main() {\n    // Iteração de 0 a 9 (total de 10 elementos)\n    for i := 0; i < 10; i++ {\n        fmt.Println(i)\n    }\n}

Este código é extremamente eficiente: o compilador o transforma em um simples incremento de registro. Sem alocações de memória, sem overhead. É assim que os desenvolvedores Go escrevem código em produção.

Variações do for clássico

Você pode facilmente alterar o valor inicial e o passo:

// De 5 a 15\nfor i := 5; i <= 15; i++ {\n    fmt.Println(i)\n}\n\n// Apenas números pares de 0 a 20\nfor i := 0; i <= 20; i += 2 {\n    fmt.Println(i)\n}\n\n// Ordem inversa: de 10 a 1\nfor i := 10; i >= 1; i-- {\n    fmt.Println(i)\n}

Esta abordagem é o padrão ouro para iteração por intervalos numéricos em Go. É simples, clara e não requer importação de pacotes adicionais.

Método nº 2: Usando range com slice (para fãs do Python)

Se você sente muita falta do estilo Python, pode criar um slice e percorrê-lo com range. Mas cuidado: isso impacta fortemente o desempenho.

package main\n\nimport "fmt"\n\nfunc main() {\n    // Cria um slice de números de 0 a 9\n    numbers := make([]int, 10)\n    for i := range numbers {\n        numbers[i] = i\n    }\n\n    // Agora usa range para iterar\n    for _, num := range numbers {\n        fmt.Println(num)\n    }\n}

Por que isso é ruim? Alocação de memória. Cada vez que você cria um slice, o Go aloca memória no heap. Para um intervalo de 10 elementos é imperceptível, mas para 10 milhões já vira problema.

Benchmark: for vs range com slice

Vamos aos números (iteração de 1.000.000 números):

\n
• For clássico: ~2,5 ms, 0 alocações
\n
• Range com slice: ~45 ms, 1 alocação (8 MB)
\n

Uma diferença de 18 vezes! E isso apenas para um milhão de elementos. Para intervalos maiores, a diferença só aumenta.

Método nº 3: Usando bibliotecas (iter, lo, e outras)

A comunidade Go não para de evoluir. Existem bibliotecas de terceiros que adicionam açúcar sintático para iteração por intervalos. Vejamos duas populares:

3.1 Pacote iter (experimental, Go 1.23+)

A partir do Go 1.23, a biblioteca padrão ganhou um pacote experimental iter, que permite criar iteradores. Ainda não está estável, mas já disponível:

package main\n\nimport (\n    "fmt"\n    "iter"\n)\n\nfunc main() {\n    // Cria um iterador de 0 a 9\n    seq := iter.Seq[int](func(yield func(int) bool) {\n        for i := 0; i < 10; i++ {\n            if !yield(i) {\n                return\n            }\n        }\n    })\n\n    for num := range seq {\n        fmt.Println(num)\n    }\n}