Les boucles

1 . Introduction

Dans ce tutoriel, nous allons apprendre à utiliser les boucles en Ruby. Les boucles vont permettre la répétition d’instructions.

2 . La boucle While

Comme dans de nombreux langages, la boucle ``while`` permet de **répéter des instructions** tant que la condition est **vraie**. Par exemple, nous allons créer une variable ``number`` et lui attribuer la valeur ``1``. Nous allons demander à la boucle d’aller jusqu’à ``10`` et d’ajouter ``1`` à chaque tour de boucle et d’afficher la nouvelle valeur de la variable : ``` number = 1 while number <= 10 # Tant que number est inférieur ou égal à 10, la boucle tourne. print "#{number }" number = number + 1 # On incrémente number de 1 à chaque tour de boucle pour que sa valeur atteigne 10. end ``` On obtiendra le résultat suivant : 

begin - while

La structure ``begin-while`` oblige la boucle à exécuter le code au moins une fois (même si la condition est fausse). Reprenons notre exemple précédent où la variable ``number`` était égale à ``1``. On incrémentait de 1 sa valeur en l'affichant à chaque tour de boucle jusqu'à ce qu'il atteigne 10. Ici, on va initialiser ``number`` à 15 et obliger la boucle à l'afficher alors qu'il est supérieur à 10 : ``` number = 15 begin print "#{number} " end while number <= 10 ``` On obtiendra le résultat suivant : 

until

La structure ``until`` va fonctionner de la même façon qu'on a pu voir précédemment dans **les conditions**. Elle est le contraire de ``while`` et va donc faire tourner la boucle pendant que la condition est **fausse** et s'arrêter quand la condition sera **vraie**. Continuons sur le même exemple que pour la boucle ``while`` : ``` number = 1 until number > 10 # Jusqu’à ce que number soit strictement plus grand que 10, la boucle tourne. print "#{number } " number = number + 1 end ``` *Remarquez que le symbole ``<=`` qu'on avait pour la boucle ``while`` a été remplacé par ``>`` pour la boucle ``until``* On obtiendra donc le même résultat que pour la boucle ``while`` : 

3 . La boucle for

La boucle ``for`` permet d’exécuter des instructions pour chaque élément d’un **intervalle** : ``` for number in 0..10 # intervalle de 0 à 10 print "#{number} " # instruction end ``` Obtiendra le résultat suivant :  La boucle ``for`` a donc exécuté l'instruction ``print`` pour chaque élément de l'intervalle (0, 1, 2, 3, .., 10). *Contrairement à ce qu'on a vu dans un précédent tutoriel sur ``when``, l'intervalle ici n'est parcouru que d'entier en entier d'où le résultat.*

4 . Contrôler l'exécution d'une boucle

Il existe quelques mots clés à inclure dans nos boucles qui vont nous permettre de contrôler leur exécution : - ``break`` - ``next`` - ``redo`` Découvrons leur utilité sans plus attendre !

break

``break`` va nous permettre d'interrompre la boucle à un moment donné que nous allons choisir. Reprenons notre exemple ``number`` : On va demander à la boucle de s'arrêter quand ``number`` sera supérieur à 10. ``` number = 1 while true print "#{number} " break if number > 10 number = number + 1 end ``` On obtient donc le résultat suivant :  Contrairement à ce qu'on pourrait penser, on obtient quand même le nombre ``11``. Pourquoi ? Simplement, ``11`` rentre dans la condition ``if`` et le ``break`` s'exécute. La boucle va donc s'arrêter à son 11ème tour.

next

``next`` permet de sauter un tour de boucle. Reprenons notre exemple ``number``, nous allons faire nos tours de boucle dans notre intervalle de 0 à 10 mais on va **éviter le 2** : ``` for number in 0..10 next if number == 2 print "#{number} " end ``` On obtient bien le résultat recherché : 

redo

``redo`` permet de refaire un tour de boucle. On va prendre l'exemple des chiffres entre 1 et 10 et utiliser redo pour faire apparaitre 2 fois les entiers de l'intervalle : ``` firstNumber = 1 # va nous permettre de savoir quand refaire un tour de boucle for secondNumber in 1..5 puts secondNumber if secondNumber == firstNumber firstNumber = firstNumber + 1 # on incrémente firstNumber à chaque fois qu'il est égal à secondNumber redo end end ``` On obtient le résultat suivant : 

5 . La boucle loop

La boucle ``loop`` est une boucle infinie. **Il faut faire très attention, les boucles infinie ont tendance à abimer les ordinateurs, il est important de forcer à quitter l'espace de travail pour mettre fin à la boucle infinie.** Néanmoins, en Ruby, nous avons la chance de pouvoir stopper ces boucles infinies avec le mot-clé ``break`` que nous avons vu précédemment ! Voici un exemple de l'utilisation de la boucle ``loop`` sans interruption (**A NE PAS REPRODUIRE**) : ``` number = 1 loop do puts number number = number + 1 end ``` Comme on peut le voir dans le code, number sera incrémenté à l'infini, mais en rajoutant ``break``, on va pouvoir l'arrêter par exemple à ``15`` : ``` number = 1 loop do puts number break if number == 15 number = number + 1 end ``` On obtient bien le résultat suivant :  Rappelez-vous : dès qu'il y a la boucle ``loop``, il faut **absolument** utiliser un mot-clé pour l'arrêter.