Les boucles sont un autre type de structure basique dans les langages de programmation comme le sont les conditions que nous avons déjà vu. D'ailleurs les boucles utilisent les conditions, je vous invite donc à relire le chapitre les concernant avant de continuer avec celui-ci.
D'une manière générale, une boucle permet de lire plusieurs fois un segment de code. Ce comportement est notamment mis à profil avec les tableaux afin que toutes les valeurs du tableaux soient exposées à ce même segment de code.
While[]
while [condition] do
[segment de code]
end
While en anglais signifie "tant que". La boucle lit et continue de lire le segment de code écrit entre les mots clés do et end tant que la condition est vraie. Lorsque le programme arrive au mot-clé while, il évalue la condition. Si elle est vraie, il rentre dans la boucle, lit le code jusqu'au mot clé end puis reviens au mot clé while puis réévalue la condition et ainsi de suite... Le programme ne s’arrêtera pas de boucler tant que la condition reste vraie. Lorsqu'elle deviens fausse, le programme termine de lire le segment de code, puis continue à la suite de la boucle lorsqu'il se rend compte que la condition est devenue fausse.
Exemple :
print( "Début de la boucle" ) i = 1 while i <= 10 do -- "tant que la valeur de i est inférieure ou égale à 10" print(i) i = i + 1 end print( "Fin de la boucle" ) -- ce code vous affiche : -- Début de la boucle -- 1 -- 2 -- ... -- 9 -- 10 -- Fin de la boucle
Ici la condition de la boucle est que la variable i soit strictement inférieure à 11. Mais elle est incrémentée dans la boucle, c'est à dire que quelque soit sa valeur, on lui ajoute 1 à chaque tour. i devient égale à 11 à la fin du tour où elle a débuté avec la valeur 10. À ce moment là, la condition de la boucle n'est plus vrai et le programme continue de lire le script à la suite de la boucle.
Repeat[]
repeat [segment de code] until [condition]
Repeat Until signifie "répète jusqu'à ce que". C'est un peu l'inverse d'une boucle While. Avec cette boucle, le segment de code est lut toujours au moins une fois et jusqu'à ce que la condition soit vraie. C'est à dire que à l'inverse de la boucle While le programme va boucler tant que la condition est fausse. L'autre point important avec cette boucle c'est que comme la condition est située après le segment de code, celui-ci sera toujours lu au moins une fois, même si la condition est vraie avant même de commencer à lire la boucle.
print( "Début de la boucle" ) i = 1 repeat print(i) i = i + 1 until i > 10 -- vous noterez que i > 10 est l'inverse i <= 10 (la condition utilisée plus haut avec while) print( "Fin de la boucle" ) -- ce code vous affiche la même chose qu'avec la boucle while
Break, casser une boucle[]
Il est possible de sortir d'une boucle et de la stopper à n'importe quel moment grâce au mot clé break. Lorsque le programme le lit, il s’arrête immédiatement de lire la boucle, sans finir le segment de code ni réévaluer la condition.
print( "Début de la boucle" )
i = 1
while i < 11 do
print(i)
if i == 5 then
break
end
i = i + 1
end
print( "Fin de la boucle" )
-- ce code vous affiche :
-- Début de la boucle
-- 1
-- 2
-- 3
-- 4
-- 5
-- Fin de la boucle
Break fonctione avec toutes les boucles : While, Repeat et la dernière boucle, For.
For[]
For numérique[]
Dans les exemples ci-dessus, nous avons créé et incrémenté manuellement une variable puis nous avons vérifié sa valeur pour déterminer si la boucle devait continuer à être lue. Cette version de la boucle For permet de faire exactement ça, mais de manière plus condensée.
for variable = [début], [fin] do [segment de code] end -- ou bien : for variable = [début], [fin], [pas] do [segment de code] end
[début], [fin] et [pas] sont à remplacer par des nombres. Le pas est la valeur qui est ajoutée à la variable à chaque fin de tour de boucle. Si il n'est pas indiqué, il vaut par défaut +1.
Exemple :
for i = 1, 10 do print( i ) end -- vous affiche : -- 1 -- 2 -- ... -- 9 -- 10 for i = 1, 10, 2 do print( i ) end -- vous affiche : -- 1 -- 3 -- 5 -- 7 -- 9
La valeur de début peut être supérieure à la valeur de fin, mais dans ce cas le pas doit obligatoirement être indiqué et être négatif (afin que la boucle compte à rebours).
for i = 10, 1, -2 do
print( i )
end
-- vous affiche :
-- 10
-- 8
-- 6
-- 4
-- 2
Les boucles For numériques peuvent déjà être utilisées pour parcourir des tableaux numérotés assez facilement. Il y a juste deux "trucs" à se rappeler du chapitre sur les tableaux. D'une part que la taille d'un tableau, qui correspond justement au dernier l'index de celui-ci se récupère en faisant précéder le nom du tableau d'un croisillon. Et d'autre part, qu'il est possible d'écrire une variable entre les crochets lors de la lecture dans le tableau; c'est alors la valeur de la variable qui est utilisée comme clé.
tableau = { "un", "deux", "trois" }
for i = 1, #tableau do -- ici, #tableau vaut 3
print( tableau[i] )
-- i va successivement prendre la valeur 1 puis 2 puis 3
-- donc on va successivement afficher la valeur de tableau[1] puis tableau[2] puis tableau[3]
end
-- vous affiche :
-- un
-- deux
-- trois
Vous pouvez rajouter des valeurs dans le tableau et vous verrez qu'elles s'afficheront sans devoir modifier quoi que ce soit au code de la boucle.
L'inconvénient est que ce type de boucle ne peut pas (ou pas correctement) afficher le contenu des tableaux lorsque les clés ne sont pas numériques (ou sont numériques mais pas continguës).
C'est précisément à cela que sert la boucle For spécialisée dans les tableaux.
For pour les tableaux[]
Là encore il y aura deux utilisations légèrement différentes, l'une pour les tableaux numérotés dont les clés sont contiguës, et l'autre pour n'importe quels tableaux.
for cle, valeur in ipairs( [tableauNumérique] ) do [code] end -- ou bien for cle, valeur in pairs( [tableau] ) do [code] end
La différence entre les deux est l'utilisation des itérateurs ipairs() ou pairs(). Sachez juste que ce sont des fonctions qui vont "présenter" le contenus du tableau à la boucle. Le tableau à parcourir doit être placé entre les parenthèses. Les variables cle et valeur peuvent être nommées autrement mais la boucle s'attend à trouver deux variables séparées par une virgule entre les mots clés for et in.
Le fonctionnement de la boucle est très simple : à chaque tour, les variables cle et valeur sont remplies respectivement avec la clé et la valeur de l'entrée (de la "ligne") du tableau qui est actuellement lue par la boucle.
ipairs()[]
C'est l'itérateur spécialisé pour les tableaux numérotés. Le résultat est exactement le même qu'avec la boucle for numérique comme dans le dernier exemple.
t = { "un", "deux", "trois" }
for cle, valeur in ipairs(t) do
print( cle, valeur )
-- souvenez vous que la fonction print() peut afficher plusieurs valeurs à la fois
-- dans l'appel (ci-dessus), les variables sont séparées par des virgules
-- dans la fenètre "Runtime Report", les valeurs seront séparées par un point d'interrogation.
end
-- vous affiche :
-- 1?un
-- 2?deux
-- 3?trois
Mais ici aussi, la boucle s’arrête lorsqu'elle rencontre la première clé qui n'est pas associée à une valeur, même si d'autre clés supérieure existent. La seule différence à l'usage entre cette boucle et le dernier exemple de boucle numérique est la manière dont on accède à la clé et à la valeur.
-- les deux boucles ci-dessous parcourent les tableaux exactement de la même manière for i = 1, #tableau do print( i, tableau[i] ) end for cle, valeur in ipairs(tableau) do print( cle, valeur ) end
pairs()[]
Cet itérateur fait dans la simplicité : il parcourt toutes les clés du tableau, quelque soit leur type.
Exemple :
tableau = { [{}] = "tableau", "un", deux = "deux", [3] = "trois", }
for cle, valeur in pairs(tableau) do
print( cle, valeur )
end
-- vous affiche quelque chose comme :
-- 1?un
-- 3?trois
-- table: 051329D0?tableau
-- deux?deux
Conclusion[]
Les boucles permettent de lire plusieurs fois un segment de code selon une condition. La boucle For est particulièrement adaptée pour parcourir un tableau et exposer toutes ses entrées (quelque soit leur nombre) au même segment de code.
Récapitulatif des boucles :
-- while et repeat while [tant que condition est vraie] do [code] end repeat [code] until [tant que condition est fausse] -- boucle For numérotée pour itérer facilement sur un nombre for variable = [début], [fin], [pas] do [code] end -- ou bien (spécifier le pas est optionnel) : for variable = [début], [fin] do -- le pas est ici égal à +1 [code] end -- utilisation pour parcourir un tableau numéroté : for variable = 1, #tableau do -- 'variable' est la clé -- 'tableau[variable]' est la valeur end -- boucle For avec itérateur pour parcourir un tableau : -- ipairs() pour les tableaux numérotés for cle, valeur in ipairs( [tableauNuméroté] ) do [code] end -- pairs() pour parcourir n'importe quelle clé for cle, valeur in pairs( [tableau] ) do [code] end