Comment utiliser les boucles dans Ruby

Les programmes informatiques doivent souvent effectuer des actions plusieurs fois, pas une seule fois. Par exemple, un programme qui imprime tous vos nouveaux e-mails devra imprimer chaque e-mail à partir d'une liste, pas seulement un e-mail. Pour ce faire, des constructions appelées boucles sont utilisées. Une boucle répétera les instructions qu'elle contient plusieurs fois jusqu'à ce qu'une condition soit remplie.

Boucles

Le premier type de ces boucles est une boucle while. Les boucles while exécuteront toutes les instructions qu'elles contiennent tant que l'instruction conditionnelle reste vraie. Dans cet exemple, la boucle augmente continuellement la valeur de la variable je par un. Tant que la déclaration conditionnelle je < 10 est vrai, la boucle continuera d'exécuter l'instruction i + = 1 ce qui ajoute un à la variable.

#! / usr / bin / env rubis
i = 0
alors que je < 10
i + = 1
fin
met i

Jusqu'à boucles

Les boucles until sont presque identiques aux boucles while, sauf qu'elles bouclent tant que l'instruction conditionnelle est faux. La boucle while va boucler tant que la condition est vraie, la boucle until va boucler jusqu'à la condition est vraie. Cet exemple est l'équivalent fonctionnel de l'exemple de boucle while, sauf en utilisant une boucle until, jusqu'à i == 10 . La variable est incrémentée de un jusqu'à ce que sa valeur soit égale à dix.

#! / usr / bin / env rubis
i = 0
jusqu'à i == 10
i + = 1
fin
met i

Boucle le "Ruby Way"

Bien que les boucles while et until plus traditionnelles soient utilisées dans les programmes Ruby, les boucles basées sur la fermeture sont plus courantes. Il n'est même pas nécessaire de comprendre ce que sont les fermetures ou comment elles fonctionnent pour utiliser ces boucles; en fait, ils sont considérés comme des boucles normales bien qu'ils soient très différents sous le capot.

La boucle du Times

le fois La boucle peut être utilisée sur n'importe quelle variable contenant un nombre ou utilisée sur un nombre lui-même. Dans l'exemple suivant, la première boucle est exécutée 3 fois et la deuxième boucle, quelle que soit la fréquence, est entrée par l'utilisateur. Si vous entrez 12, il s'exécutera 12 fois. Vous remarquerez que la boucle times utilise la syntaxe point (3.times do) plutôt que la syntaxe des mots clés utilisée par la boucle while et until. Cela a à voir avec la façon dont la boucle de temps fonctionne sous le capot, mais elle est utilisée de la même manière pendant un certain temps ou jusqu'à ce que la boucle soit utilisée.

#! / usr / bin / env rubis
3. fois
met "Cela sera imprimé 3 fois"
fin
imprimer "Entrez un numéro:"
num = gets.chomp.to_i
nombre de fois
met "Ruby is great!"
fin

La boucle Each

le chaque la boucle est peut-être la plus utile de toutes les boucles. Chaque boucle prendra une liste de variables et exécutera un bloc d'instructions pour chacune d'entre elles. Étant donné que presque toutes les tâches informatiques utilisent des listes de variables et doivent faire quelque chose avec chacune d'elles dans la liste, la boucle each est de loin la boucle la plus courante dans le code Ruby. Une chose à noter ici est l'argument du bloc d'instructions de la boucle. La valeur de la variable actuelle que la boucle examine est affectée au nom de la variable en caractères de canal, qui est | n | dans l'exemple. La première fois que la boucle s'exécute, n sera égale à "Fred", la deuxième fois que la boucle s'exécutera, elle sera égale à "Bob" et ainsi de suite.

#! / usr / bin / env rubis
# Une liste de noms
names = ["Fred", "Bob", "Jim"]
names.each do | n |
met "Bonjour # n"
fin