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

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 dynamiquement pendant 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 répétition jusqu’à la boucle. Cet article couvre les boucles while et repeat until. 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 fantaisiste pour les symboles que vous pouvez reconnaître dans les cours de mathématiques. Les opérateurs valides en Lua sont :

Ceux-ci sont connus sous le nom d’opérateurs relationnels parce qu’ils incitent à une enquête sur la façon dont deux valeurs sont liées l’une à l’autre. Il existe également des opérateurs logiques, qui ont la même signification 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 :

Voici quelques exemples de conditions :

• foo > 3: La variable est-elle foo est supérieur à 3 ? Le foo doit être supérieur ou égal à 4 pour satisfaire à cette condition.

• foo >= 3: Est foo supérieur ou égal à 3 ? Le foo doit être supérieur ou égal à 3 pour satisfaire à cette condition.

• foo > 3 and bar < 1: Est foo supérieur à 3 alors que bar est inférieur à 1 ? Pour que cette condition soit vraie, le foo variable doit être 4 ou plus au même moment que bar est 0.

• foo > 3 or bar < 1: Est foo supérieur à 3 ? Alternativement, est bar Moins que 1? Si foo est de 4 ou plus, ou bar est 0, alors cette condition est vraie. Ce qui se passe si foo est de 4 ou plus alors que bar vaut 0 ? La réponse apparaît plus loin dans cet article.

Boucle tant que

Une boucle while exécute des instructions aussi longtemps que certaines conditions est satisfait. Par exemple, supposons que vous développiez une application pour surveiller une apocalypse zombie en cours. Lorsqu’il ne reste plus de zombies, 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 regarder 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’il s’agisse essentiellement d’une boucle while avec une instruction “catch”. Supposons que vous avez commencé à jardiner et que vous souhaitez 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 indéfiniment. Il s’agit souvent d’un bogue 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 or bar < 1alors que se passe-t-il quand foo est de 4 ou plus alors que bar vaut 0 ?

Voici le code pour résoudre cette énigme, avec un cran de sécurité à l’aide du break déclaration juste 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 erronée est la or qui permet à cette boucle de continuer à la fois lorsque foo est supérieur à 3 et lorsque bar est inférieur à 1. Le and L’opérateur a un effet différent, mais je vous laisse explorer cela.

Les boucles infinies ont en fait leur utilité. Les applications graphiques utilisent ce qui est techniquement des boucles infinies pour garder la fenêtre de l’application ouverte. Il n’y a aucun moyen de savoir combien de temps votre utilisateur a l’intention d’utiliser l’application, donc le programme s’exécute indéfiniment jusqu’à ce que l’utilisateur sélectionne Arrêter. La condition simple utilisée dans ces cas est évidemment toujours satisfaite. Voici un exemple de boucle infinie, encore une fois avec un cran 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 satisfait car true est toujours vrai. C’est la manière concise d’écrire while 1 == 1 ou quelque chose de similaire éternellement vrai.

Boucles en Lua

Comme vous pouvez le constater à partir de l’exemple de code, bien qu’il existe différentes implémentations, les boucles fonctionnent toutes essentiellement dans le même but. Choisissez celui qui a du sens pour vous et qui fonctionne le mieux avec le traitement que vous devez effectuer. Et juste au cas où vous en auriez besoin : le raccourci clavier pour terminer une boucle d’emballement est Ctrl+C.