Ruby/Itérateurs

**Itérateurs**
Leçon : Ruby

Chapitre n^o 12
Chap. préc. :	Autres variables
Chap. suiv. :	Symboles

En raison de limitations techniques, la typographie souhaitable du titre, « Ruby : Itérateurs
Ruby/Itérateurs », n'a pu être restituée correctement ci-dessus.

Définition

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 :

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 :

Exemple

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).

Exemple

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) :

Exemple

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 :

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 :

Exemple

array = ["zero", "un", "deux"]

Nous utilisons each de cette manière :

Exemple

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 :

Exemple

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 :

Exemple

chaine = "Bonjour !
Comment allez-vous ?"

Propriété

Le saut de ligne peut être remplacé par \n, qui ne compte que pour un seul caractère.

Ainsi, notre chaîne équivaut à :

Exemple

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 :

Exemple

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 :

Exemple

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) :

Exemple

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 :

Exemple

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 :

Exemple

hash = { "un" => 1, "deux" => 2 }

Pour parcourir les paires clés-valeurs du hachage, nous procédons comme suit :

Exemple

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 :

Exemple

for key, value in hash
  puts "#{key} => #{value}"
end

Ruby

Autres variables

Symboles