Les programmes informatiques doivent souvent effectuer des actions un certain nombre de 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 la déclarations à l'intérieur 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 i <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 seconde boucle, quelle que soit la fréquence, est entrée par l'utilisateur. Si vous saisissez 12, il s'exécuterait 12 fois. Vous remarquerez que la boucle de temps utilise le point syntaxe (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'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, chaque boucle est de loin la boucle la plus courante dans 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