Les itérateurs permettent d'accéder, tout comme la boucle for, à tous les éléments d'un ensemble un à un.
Parcourir des nombres
Pour chaque nombre d'un ensemble
Comme nous l'avons déjà vu, une boucle for permet de parcourir un ensemble de nombres de la manière la plus simple qui soit, par exemple :
for n in 2..7
puts n
end
n prend successivement la valeur de 2, 3, 4, 5, 6 et 7.
Il est possible de réécrire cette boucle à l'aide d'une méthode : upto (Integer#upto). Cette méthode de la classe Integer s'applique à un entier, elle l'incrémente et exécute un bloc d'instructions jusqu'à atteindre le nombre passé en paramètre. Voici un exemple permettant d'obtenir la même chose que la boucle du dessus :
2.upto(7) { |x| puts x }
Le bloc |x| puts x, délimité par des accolades est exécuté 6 fois, x prend successivement les valeurs 2, 3, 4, 5, 6 et 7. Le nom de la variable, ici x, est mis entre deux barres et peut être changé. Le bloc de code peut être délimité par les mots-clés do et end (à la place des accolades) et peut contenir autant d'instructions que vous le voulez (ces deux remarques sont valables pour tout ce que nous verrons dans ce chapitre).
2.upto(7) do |var|
puts var
end
Il existe une méthode permettant de faire la même chose à l’envers : downto (Integer#downto) :
7.downto(2) { |x| puts x }
x prend les valeurs 7, 6, 5, 4, 3 et 2. Les remarques faites plus haut sont valables ici aussi.
Un certain nombre de fois
Nous pouvons exécuter un bloc de code un certain nombre de fois, c’est ce que nous permet la méthode times (Integer#times). Elle s'applique à un entier et exécute le bloc qu'on lui fournit autant de fois ; voici un exemple :
2.times { |x| puts x }
# => 0 1
Ainsi, l'instruction puts x est exécutée 2 fois (times est appelée sur l'entier 2). L'itération commençant à 0, x prend successivement les valeurs 0 et 1.
Parcourir un tableau
Nous disposons de la méthode each (Array#each) qui exécute un bloc d'instructions pour chaque élément du tableau sur lequel on l'invoque. Considérons ce tableau :
array = ["zero", "un", "deux"]
Nous utilisons each de cette manière :
array.each { |n| puts n }
# => zero un deux
Le fonctionnement est le même que celui de times : n prend successivement les valeurs des éléments du tableau array, à savoir "zero", "un" et "deux".
puts n est exécuté pour chaque valeur de n.
Voici l'équivalent avec une boucle for :
for n in array
puts n
end
Parcourir une chaîne de caractères
Une chaîne de caractères peut être considérée comme un tableau et peut donc être parcourue tout aussi simplement. Considérons cette chaîne de caractères :
chaine = "Bonjour !
Comment allez-vous ?"
Le saut de ligne peut être remplacé par \n, qui ne compte que pour un seul caractère.
Ainsi, notre chaîne équivaut à :
chaine = "Bonjour !\nComment allez-vous ?"
La classe String dispose, tout comme la classe Array, d'une méthode each (String#each) permettant de parcourir les chaînes de caractères. Le fonctionnement est similaire à celui de Array#each :
chaine.each { |l| puts l }
puts l est exécuté pour chaque portion de la chaîne sur laquelle on l'appelle.
La chaîne a donc été découpée suivant les sauts de ligne. En effet, la méthode String#each peut prendre en argument un caractère afin de délimiter les portions de chaînes, par défaut ce caractère est \n. Si nous voulons par exemple traiter la chaîne mot par mot, nous précisons que le délimiteur doit être un espace :
chaine.each(' ') { |w| puts w }
La boucle for nous permet d'obtenir le même résultat que each sans paramètre (c'est-à-dire en considérant les retours à la ligne comme des séparateurs) :
for n in chaine
puts n
end
Une chaîne de caractères est en fait un tableau d'octets. Vous disposez d'une autre méthode, each_byte (String#each_byte) qui vous permet de traiter une chaîne octet par octet (un caractère occupant la place d'un octet en mémoire). Voici comment traiter une chaîne caractère par caractère, après une conversion à l'aide de la méthode chr :
chaine.each_byte { |c| puts c.chr }
Pour ne pas entrer dans les détails, souvenez-vous seulement que c.chr désigne successivement chaque caractère de la chaîne sur laquelle est invoquée la méthode each_byte.
Parcourir un hachage
Parcourir un hachage se fait quasiment de la même manière que pour un tableau : à l'aide de la méthode each de la classe Hash (Hash#each). Considérons ce hachage :
hash = { "un" => 1, "deux" => 2 }
Pour parcourir les paires clés-valeurs du hachage, nous procédons comme suit :
hash.each { |k, v| puts "#{k} => #{v}" }
# => un => 1
# => deux => 2
k et v (on utilise plus généralement key et value), séparés par une virgule, représentent successivement les clés et les valeurs associées du hachage sur lequel est appelée la méthode each. Quand k vaut un, v est égal à 1.
Une boucle for peut là aussi nous permettre d'obtenir le même résultat :
for key, value in hash
puts "#{key} => #{value}"
end