Itération sur une plage de nombres en Go : 3 approches puissantes

Pourquoi la question "Is there a way to iterate over a range of integers?" est-elle si populaire ?

Si vous êtes venu à Go depuis Python, vous vous souvenez sûrement de l'élégant for i in range(10):. En Python, cela fonctionne comme sur des roulettes. En Go... c'est un peu différent. La question sur Stack Overflow avec ce titre a recueilli des milliers de vues — et ce n'est pas un hasard. Les développeurs habitués aux abstractions de haut niveau sont souvent perdus face à la syntaxe minimaliste de Go.

Dans cet article, nous allons passer en revue toutes les façons d'itérer sur une plage d'entiers en Go : du classique for aux utilitaires modernes. Vous découvrirez quelle approche choisir pour des performances maximales, et laquelle pour la lisibilité du code. C'est parti !

Méthode n°1 : Le for classique (Go idiomatique)

Go est un langage de pragmatiques. Il n'a pas de range intégré pour les nombres, mais il dispose d'un puissant for. La façon la plus simple et la plus performante est d'utiliser une boucle à trois composants :

package main\n\nimport "fmt"\n\nfunc main() {\n    // Itération de 0 à 9 (10 éléments au total)\n    for i := 0; i < 10; i++ {\n        fmt.Println(i)\n    }\n}

Ce code est extrêmement efficace : le compilateur le transforme en un simple incrément de registre. Pas d'allocations mémoire, pas de frais généraux. C'est exactement ainsi que les développeurs Go écrivent en production.

Variations du for classique

Vous pouvez facilement modifier la valeur de départ et le pas :

// De 5 à 15\nfor i := 5; i <= 15; i++ {\n    fmt.Println(i)\n}\n\n// Uniquement les nombres pairs de 0 à 20\nfor i := 0; i <= 20; i += 2 {\n    fmt.Println(i)\n}\n\n// Ordre inverse : de 10 à 1\nfor i := 10; i >= 1; i-- {\n    fmt.Println(i)\n}

Cette approche est l'étalon-or pour l'itération sur une plage de nombres en Go. Elle est simple, compréhensible et ne nécessite pas d'importer de paquets supplémentaires.

Méthode n°2 : Utilisation de range avec une slice (pour les amateurs de Python)

Si Python vous manque vraiment, vous pouvez créer une slice et la parcourir avec range. Mais attention : cela impacte fortement les performances.

package main\n\nimport "fmt"\n\nfunc main() {\n    // Création d'une slice de nombres de 0 à 9\n    numbers := make([]int, 10)\n    for i := range numbers {\n        numbers[i] = i\n    }\n\n    // Utilisation de range pour l'itération\n    for _, num := range numbers {\n        fmt.Println(num)\n    }\n}

Pourquoi est-ce mauvais ? L'allocation mémoire. Chaque fois que vous créez une slice, Go alloue de la mémoire dans le tas. Pour une plage de 10 éléments, c'est imperceptible, mais pour 10 millions, c'est déjà un problème.

Benchmark : for vs range avec slice

Regardons les chiffres (itération sur 1 000 000 de nombres) :

\n
• For classique : ~2,5 ms, 0 allocations
\n
• Range avec slice : ~45 ms, 1 allocation (8 Mo)
\n

Une différence de 18 fois ! Et ce n'est que pour un million d'éléments. Pour des plages plus grandes, l'écart ne fait que se creuser.

Méthode n°3 : Utilisation de bibliothèques (iter, lo, et autres)

La communauté Go ne reste pas inactive. Il existe des bibliothèques tierces qui ajoutent du sucre syntaxique pour l'itération sur une plage. Examinons deux populaires :

3.1 Paquet iter (expérimental, Go 1.23+)

Depuis Go 1.23, un paquet expérimental iter est apparu dans la bibliothèque standard, permettant de créer des itérateurs. Il n'est pas encore stable, mais déjà disponible :

package main\n\nimport (\n    "fmt"\n    "iter"\n)\n\nfunc main() {\n    // Création d'un itérateur de 0 à 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}