Lua - Boucles : Maîtriser l'Art de la Répétition

Bonjour, aspirants programmeurs ! Bienvenue dans notre voyage passionnant à travers le monde des boucles Lua. En tant que votre enseignant informatique de quartier bienveillant, je suis ravi de vous guider à travers ce concept fondamental. Les boucles sont comme les DJs de la programmation - elles gardent la fête en continuant de répéter les bonnes choses ! Alors, plongeons dedans et explorons comment nous pouvons faire danser notre code au rythme de la répétition.

Qu'est-ce que les Boucles ?

Avant de nous plonger dans les détails, comprens ce qu'elles sont. Imaginez que vous êtes chargé d'écrire "J'aime Lua" sur un tableau noir 100 fois. Ça paraît fastidieux, n'est-ce pas ? C'est là que les boucles viennent à la rescousse ! Elles nous permettent d'exécuter un bloc de code plusieurs fois sans avoir à l'écrire encore et encore. C'est comme avoir un stylo magique qui écrit pour vous !

Types de Boucles en Lua

Lua nous offre trois types principaux de boucles. Rencontrons notre famille de boucles :

Type de Boucle	Description	Cas d'Utilisation
while	Répète un bloc de code tant qu'une condition est vraie	Lorsque vous ne savez pas combien de fois vous devez répéter
repeat	Exécute un bloc de code au moins une fois, puis répète tant qu'une condition est vraie	Lorsque vous voulez vous assurer que le code s'exécute au moins une fois
for	Répète un bloc de code un nombre spécifique de fois	Lorsque vous savez exactement combien de fois vous devez répéter

Maintenant, explorons chacun de ces types de boucles en détail.

La Boucle while : La Répéteur Prudent

La boucle while est comme un ami prudent qui vérifie toujours avant d'agir. Elle continue d'exécuter un bloc de code tant qu'une condition spécifiée est vraie.

local count = 1
while count <= 5 do
print("Le compteur est : " .. count)
count = count + 1
end

Dans cet exemple, nous démarçons avec count à 1. La boucle vérifie si count est inférieur ou égal à 5. Si c'est le cas, elle imprime le compteur actuel et puis l'augmente de 1. Ce processus se répète jusqu'à ce que count devienne 6, auquel point la condition devient fausse et la boucle s'arrête.

Sortie :

Le compteur est : 1
Le compteur est : 2
Le compteur est : 3
Le compteur est : 4
Le compteur est : 5

La Boucle repeat : Le Faiseur Optimiste

La boucle repeat est comme celui qui agit d'abord et pose des questions après. Elle exécute toujours le bloc de code au moins une fois avant de vérifier la condition.

local num = 1
repeat
print("Le nombre est : " .. num)
num = num + 1
until num > 5

Ici, nous imprimons le nombre et l'augmentons. La boucle continue jusqu'à ce que num soit supérieur à 5. Même si num démarrait supérieur à 5, cette boucle fonctionnerait encore une fois.

Sortie :

Le nombre est : 1
Le nombre est : 2
Le nombre est : 3
Le nombre est : 4
Le nombre est : 5

La Boucle for : Le Planificateur Précis

La boucle for est comme un planificateur méticuleux. Elle est parfaite lorsque vous savez exactement combien de fois vous voulez répéter quelque chose.

Boucle Numérique for

for i = 1, 5 do
print("Itération : " .. i)
end

Cette boucle commence avec i à 1 et continue jusqu'à ce que i atteigne 5, en augmentant de 1 à chaque fois.

Sortie :

Itération : 1
Itération : 2
Itération : 3
Itération : 4
Itération : 5

Boucle for avec un Pas

Nous pouvons également spécifier une valeur de pas différente :

for i = 0, 10, 2 do
print("Nombre pair : " .. i)
end

Cette boucle commence à 0, monte jusqu'à 10, mais augmente de 2 à chaque fois, nous donnant des nombres pairs.

Sortie :

Nombre pair : 0
Nombre pair : 2
Nombre pair : 4
Nombre pair : 6
Nombre pair : 8
Nombre pair : 10

Boucle Générique for

Lua possède également une boucle générique qui peut itérer sur les éléments d'un tableau :

local fruits = {"apple", "banana", "cherry"}
for index, value in ipairs(fruits) do
print(index .. ": " .. value)
end

Cette boucle parcourt chaque élément du tableau fruits, nous donnant à la fois l'index et la valeur.

Sortie :

1: apple
2: banana
3: cherry

Instructions de Contrôle des Boucles

Parfois, nous avons besoin de prendre le contrôle de nos boucles. C'est là que les instructions de contrôle des boucles deviennent utiles.

Instruction break

L'instruction break est comme une issue d'urgence. Elle nous permet de sortir d'une boucle prématurément :

for i = 1, 10 do
if i > 5 then
break
end
print("Nombre : " .. i)
end

Cette boucle s'arrêtera dès que i deviendra supérieur à 5.

Sortie :

Nombre : 1
Nombre : 2
Nombre : 3
Nombre : 4
Nombre : 5

Instruction continue (Lua 5.2+)

Lua 5.2 a introduit l'instruction goto, qui peut être utilisée pour simuler un continue :

for i = 1, 5 do
if i % 2 == 0 then
goto continue
end
print("Nombre impair : " .. i)
::continue::
end

Cette boucle saute les nombres pairs et n'imprime que les nombres impairs.

Sortie :

Nombre impair : 1
Nombre impair : 3
Nombre impair : 5

La Boucle Infinie : Manipuler avec Précaution !

Une boucle infinie est comme une histoire sans fin. C'est une boucle qui n'a pas de point de terminaison naturel :

while true do
print("C'est une boucle infinie !")
end

Soyez prudent avec les boucles infinies ! Elles peuvent faire planter votre programme. Assurez-vous toujours d'avoir un moyen de sortir d'elles si vous les utilisez intentionnellement.

Conclusion

Félicitations ! Vous avez fait un tour d'horizon des boucles Lua. Souvenez-vous, les boucles sont des outils puissants dans votre boîte à outils de programmation. Elles vous aident à automatiser les tâches répétitives et rendent votre code plus efficace. Pratiquez l'utilisation de différents types de boucles, et bientôt vous bouclerez comme un pro !

Pour conclure, un peu d'humour programmation : Pourquoi les programmeurs préfèrent-ils le mode sombre ? Parce que la lumière attire les bugs !

Continuez à coder, continuez à apprendre, et souvenez-vous - dans le monde de la programmation, il est tout à fait normal de faire des boucles !

Credits: Image by storyset