Boucles Lua : comment utiliser while et répéter jusqu'à

Apprenez comment et quand utiliser les boucles while et répétez jusqu'à ce qu'elles soient en Lua.

Les structures de contrôle sont une caractéristique importante des langages de programmation car elles vous permettent de diriger le flux du programme en fonction de conditions qui sont souvent établies de manière dynamique lors de l'exécution du programme. Différentes langues fournissent différents contrôles, et dans Lua, il y a la boucle while, la boucle for et la boucle répéter jusqu'à. Cet article couvre les boucles while et répéter jusqu'à ce que. En raison de leur flexibilité, je couvre les boucles dans un article séparé.

Une condition est définie par une expression utilisant un opérateur, qui est un terme sophistiqué désignant des symboles que vous pouvez reconnaître dans les cours de mathématiques. Les opérateurs valides dans Lua sont :

== égal à
~= différent de
< inférieur à
> supérieur à
⇐ inférieur ou égal à
>= supérieur ou égal à

On les appelle opérateurs relationnels car ils incitent à étudier la relation entre deux valeurs. Il existe également des opérateurs logiques, qui signifient la même chose qu'en anglais et peuvent être incorporés dans des conditions pour décrire plus en détail l'état que vous souhaitez vérifier :

et
ou

Voici quelques exemples de conditions :

foo > 3 : la variable foo est-elle supérieure à 3 ? Le foo doit être égal à 4 ou plus pour satisfaire cette condition.
foo >= 3 : foo est-il supérieur ou égal à 3 ? Le foo doit être égal à 3 ou plus pour satisfaire cette condition.
foo > 3 et bar < 1 : foo est-il supérieur à 3 alors que bar est inférieur à 1 ? Pour que cette condition soit vraie, la variable foo doit être égale ou supérieure à 4 au même moment où bar est égal à 0.
foo > 3 ou bar < 1 : foo est-il supérieur à 3 ? Alternativement, bar est-il inférieur à 1 ? Si foo vaut 4 ou plus, ou si bar vaut 0, alors cette condition est vraie. Que se passe-t-il si foo vaut 4 ou plus alors que bar vaut 0 ? La réponse apparaît plus loin dans cet article.

Boucle while

Une boucle while exécute des instructions tant que certaines conditions sont satisfaites. Par exemple, supposons que vous développiez une application pour surveiller une apocalypse zombie en cours. Lorsqu’il ne reste plus de zombies, alors il n’y a plus d’apocalypse zombie :

zombie = 1024

while (zombie > 0) do
  print(zombie)
  zombie = zombie-1
end

if zombie == 0 then
  print("No more zombie apocalypse!")
end

Exécutez le code pour voir les zombies disparaître :

$ lua ./while.lua
1024
1023
[...]
3
2
1
No more zombie apocalypse!

Jusqu'à la boucle

Lua a également une construction de boucle de répétition jusqu'à ce qu'elle soit essentiellement une boucle while avec une instruction "catch". Supposons que vous vous lancez dans le jardinage et que vous souhaitiez suivre ce qu'il reste à récolter :

mytable = { "tomato", "lettuce", "brains" }
bc = 3

repeat
   print(mytable[bc])
   bc = bc - 1
until( bc == 0 )

Exécutez le code :

$ lua ./until.lua
brains
lettuce
tomato

C'est utile !

Boucles infinies

Une boucle infinie a une condition qui ne peut jamais être satisfaite, elle s'exécute donc à l'infini. Il s'agit souvent d'un bug causé par une mauvaise logique ou un état inattendu de votre programme. Par exemple, au début de cet article, j'ai posé une énigme logique. Si une boucle est configurée pour s'exécuter jusqu'à foo > 3 ou bar < 1, alors que se passe-t-il lorsque foo vaut 4 ou plus alors que bar vaut 0 ?

Voici le code pour résoudre ce casse-tête, avec un dispositif de sécurité utilisant l'instruction break au cas où :

foo = 9
bar = 0

while ( foo > 3 or bar < 1 ) do
  print(foo)
  foo = foo-1

  -- safety catch
  if foo < -800000 then
    break
  end
end

Vous pouvez exécuter ce code en toute sécurité, mais il imite une boucle infinie accidentelle. La logique défectueuse est l'opérateur or, qui permet à cette boucle de continuer à la fois lorsque foo est supérieur à 3 et lorsque bar est inférieur à 1. L'opérateur et a un effet différent, mais je vous laisse l'explorer.

Les boucles infinies ont en fait leur utilité. Les applications graphiques utilisent des boucles techniquement infinies pour garder la fenêtre de l'application ouverte. Il n'existe aucun moyen de savoir combien de temps votre utilisateur a l'intention d'utiliser l'application. Le programme s'exécute donc indéfiniment jusqu'à ce que l'utilisateur sélectionne Quitter. La condition simple utilisée dans ces cas est évidemment toujours satisfaite. Voici un exemple de boucle infinie, encore une fois avec un dispositif de sécurité intégré pour plus de commodité :

n = 0

while true do
  print(n)
  n = n+1

  if n > 100 then
  break
  end
end

La condition while true est toujours satisfaite car true est toujours vrai. C'est la manière laconique d'écrire while 1 == 1 ou quelque chose de similaire, éternellement vrai.

Boucles en Lua