Comment parcourir un tableau avec l'itérateur `.each`

Le besoin fondamental : agir sur chaque élément d'une liste

Nous savons maintenant créer des tableaux pour stocker des collections de données, comme une liste de noms ou de scores. Mais comment faire pour effectuer une action sur chaque élément de cette liste ? Par exemple, comment afficher chaque nom sur une ligne séparée ou calculer la somme de tous les scores ?

C'est le rôle de l'itération, ou du parcours de collection. Dans de nombreux langages, cela se fait avec des boucles `for` complexes qui nécessitent de gérer manuellement un compteur. Ruby, fidèle à sa philosophie de simplicité et d'élégance, propose une approche bien plus intuitive et lisible : les itérateurs. Le plus fondamental et le plus utilisé d'entre eux est la méthode .each.

La syntaxe de `.each` avec un bloc `do...end`

La méthode .each est appelée directement sur un tableau. Elle prend en argument un 'bloc de code', qui est la série d'instructions que vous souhaitez exécuter pour chaque élément. La syntaxe la plus courante pour un bloc sur plusieurs lignes utilise les mots-clés do et end.

La partie la plus importante est la variable de bloc, définie entre deux barres verticales (|...|). A chaque tour de boucle, Ruby prend l'élément suivant du tableau et l'assigne à cette variable, vous permettant de l'utiliser à l'intérieur du bloc.

fruits = ["Pomme", "Banane", "Orange"]

# On appelle .each sur le tableau 'fruits'
fruits.each do |fruit|
  # Ce code sera exécuté 3 fois.
  # 1er tour : 'fruit' vaudra "Pomme"
  # 2ème tour : 'fruit' vaudra "Banane"
  # 3ème tour : 'fruit' vaudra "Orange"
  puts "J'aime manger des #{fruit}s."
end

L'exécution de ce code affichera :

J'aime manger des Pommes.
J'aime manger des Bananes.
J'aime manger des Oranges.

Cette approche est descriptive : on lit littéralement "Pour chaque fruit dans la liste de fruits, fais ceci...".

L'alternative concise : la syntaxe avec accolades `{...}`

Pour les blocs de code qui ne contiennent qu'une seule ligne d'instruction, la communauté Ruby privilégie une syntaxe plus courte utilisant des accolades {...} à la place de do...end. Le fonctionnement est absolument identique, c'est purement une convention de style qui améliore la lisibilité.

Reprenons notre exemple précédent avec cette syntaxe concise :

fruits = ["Pomme", "Banane", "Orange"]

fruits.each { |fruit| puts "J'aime manger des #{fruit}s." }

Conseil pro : Adoptez cette convention dès maintenant. Utilisez do...end pour les blocs de plusieurs lignes qui impliquent une logique plus complexe, et {...} pour les actions simples et directes qui tiennent sur une seule ligne. C'est un signe de maîtrise du style idiomatique de Ruby.

Exemple pratique : calculer la somme d'une liste de nombres

L'itération ne sert pas qu'à afficher des choses. Elle est cruciale pour effectuer des calculs sur des collections. Imaginons que nous ayons un tableau de notes et que nous voulions calculer la somme totale.

Pour cela, nous devons initialiser une variable (par exemple total_score) à 0 avant la boucle. Ensuite, à chaque itération, nous ajouterons la note actuelle à notre total.

scores = [15, 7, 12, 18]
total_score = 0

scores.each do |score|
  # A chaque tour, on met à jour la variable 'total_score'
  total_score = total_score + score
end

puts "Le score total est : #{total_score}" # Affiche : Le score total est : 52

C'est un schéma très courant : initialiser un résultat, parcourir une collection pour le mettre à jour, puis utiliser le résultat final après la boucle.

Anticiper une question : que retourne la méthode `.each` ?

C'est un point technique mais fondamental. Une erreur commune de débutant est de croire que .each retourne un nouveau tableau avec des modifications. C'est faux. La méthode .each est utilisée pour ses effets de bord (afficher du texte, modifier une variable externe, etc.).

Peu importe ce que vous faites à l'intérieur du bloc, la méthode .each elle-même retourne toujours le tableau original sur lequel elle a été appelée, sans aucune modification. C'est une distinction cruciale avec d'autres itérateurs comme .map que vous découvrirez plus tard, qui eux sont conçus pour transformer un tableau en un autre.

numbers = [1, 2, 3]

result = numbers.each { |n| n * 2 } # Le bloc calcule n*2, mais ne stocke le résultat nulle part

puts result.inspect # Affiche : [1, 2, 3]