FANDOM


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.

WhileModifier

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.

RepeatModifier

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 boucleModifier

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

ForModifier

For numériqueModifier

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 tableauxModifier

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()Modifier

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()Modifier

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

ConclusionModifier

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

Interférence d'un bloqueur de publicité détectée !


Wikia est un site gratuit qui compte sur les revenus de la publicité. L'expérience des lecteurs utilisant des bloqueurs de publicité est différente

Wikia n'est pas accessible si vous avez fait d'autres modifications. Supprimez les règles personnalisées de votre bloqueur de publicité, et la page se chargera comme prévu.

Sur le réseau FANDOM

Wiki au hasard