Missions et structures de contrôle en Lua

Dans les tutoriels précédents, nous avons vu comment Lua permet la gestion dynamique des valeurs et des types, se distinguant toujours par sa simplicité et sa polyvalence lors de l'exécution de ces opérations.
Mais ce n'est pas tout Lua offre en termes de simplicité, il supporte classiquement les déclarations que l'on peut trouver dans les langages comme dans C ou alors PascalLorsque ces déclarations incluent des affectations et des structures de contrôle, nous pouvons même tomber sur des méthodes non conventionnelles telles que des affectations multiples et des déclarations locales.
Les devoirs en Lua Ils sont extrêmement simples, et ils fonctionnent pour changer la valeur d'une variable à un certain moment dans notre programme, voyons un exemple simple utilisant la console interactive de Lua, que l'on peut saisir en plaçant le mot réservé lua Dans la borne :

Comme nous pouvons le voir, nous avons quelques exemples simples d'affectations, en changeant la valeur des variables avec des opérations de concaténation, de l'arithmétique ou simplement en écrivant des valeurs. En plus de cela, Lua permet une affectation multiple, où une liste de valeurs est affectée à une liste de variables, en séparant toujours ces listes par des virgules pour un fonctionnement correct :

Comme on a pu le voir var1 obtenu la valeur numérique et var2 la valeur du texte, ceci selon l'ordre dans lequel l'affectation est faite. Si nous sommes des observateurs, nous voyons comment nous pouvons également alterner les valeurs des deux variables, ce qui est pratique lorsque nous travaillons avec des fonctions.
Lua vous pouvez même ajuster le nombre de valeurs pour le nombre de variables présentes, par exemple si la liste de valeurs est inférieure à la liste de variables, les variables supplémentaires reçoivent le type de valeur néant par défaut comme valeurs, voyons un exemple de ce processus :

Comme on peut le voir, les deux premières variables reçoivent leurs valeurs correspondantes et la dernière reçoit automatiquement néant comme nous l'expliquons. Il est important de mentionner que les affectations multiples ne sont pas toujours plus rapides que les affectations simples, mais elles nous permettent de nous aider à collecter plusieurs retours d'un appel de fonction pour n'en nommer que quelques-uns.
En plus des variables globales, Lua Il supporte les variables locales qui, contrairement aux globales, ont une portée limitée, qui dépend du bloc dans lequel elles ont été déclarées, voyons comment déclarer une variable locale :

Comme nous voyons la déclaration de ces variables nous les faisons avec le mot réservé localCes variables fonctionnent dans le bloc dans lequel elles ont été déclarées, par exemple on peut dire qu'un bloc peut être une structure de contrôle ou une fonction, voyons l'exemple suivant :

 x = 10 local i = 1 tandis que i <= x do local x = i * 2 print (x) i = i + 1 end if i> 20 then local xx = 20 print (x + 2) else print (x) end imprimer (x) 

Si nous exécutons la même chose dans notre terminal, nous verrons comment le résultat peut ne pas être ce que nous attendons, et c'est parce que nous avons différents blocs dans lesquels nous utilisons les variables, voyons le résultat :

Bien que le contrôle de notre programme puisse être limité, nous pouvons utiliser les délimiteurs faire la fin Pour spécifier un bloc et savoir jusqu'où nos variables locales ont une portée, voyons un exemple où nous pouvons faire ceci :

 do local var1 = 16 local var2 = var1 + 20 x = 5 y = x + var1 end - Ici se termine la portée de var1 et var2 print (x, y) print (var1, var2)

Lorsque nous l'exécuterons dans notre terminal, nous verrons que les variables x et y sont affichées sans problème car elles sont globales, mais pour var1 et var2 leur portée se termine par le bloc faire la fin, Voyons voir:

Nous pouvons souligner que l'utilisation de variables locales dans nos programmes est une bonne pratique, elles nous aident à ne pas toucher à l'environnement global avec des noms inutiles, aussi que l'accès à ces variables est beaucoup plus rapide que si nous le faisions avec des variables globales et enfin ces les variables disparaissent dès que leur portée se termine libérant ainsi de l'espace mémoire, nous recommandons donc leur utilisation dans la mesure du possible.
Structures de contrôleComme le reste des langages de programmation, Lua nous fournit un ensemble de structures de contrôle que nous pouvons utiliser dans nos programmes, en utilisant le bien connu si pour gérer les conditions et tandis que, répéter Oui pour pour les boucles itératives, où sauf répéter qui a le terminateur explicite jusqu'à et les autres se terminant par finir.
Comme dans la plupart des langages de programmation, la déclaration si vérifie une condition et exécute la partie du ensuite ou la partie de autre, où ce dernier peut être facultatif, voyons un ensemble de ces conditions comme on le voit dans nos programmes :

 if var1 <0 then var1 = 0 end if var1 max lines then show () lines = 0 end

Ici, nous avons trois types d'opérations, la base avec le ensuite, en utilisant return pour renvoyer une valeur en fonction de la condition et un morceau de code légèrement plus complet qui appelle une fonction. En plus de cela, nous pouvons écrire si imbriqué à l'aide sinon, ce qui nous évite d'avoir à utiliser plusieurs prend fin, voyons à quoi cela ressemble :

 if opération == "+" then result = a + b elseif operation == "-" then result = a - b elseif operation == "*" then result = a * b elseif operation == "/" then result = a / b else error ("Opération invalide") end

Il est important de noter que ce n'est pas seulement plus optimal mais aussi nécessaire puisque Lua n'a pas les déclarations de type changer ce type de conditions imbriquées sera donc assez courant dans nos programmes.
Comme dans d'autres langues, Lua évaluer d'abord l'état du tandis que, si la condition est fausse, la boucle se termine et sinon les lignes de code suivantes sont exécutées et le processus est répété jusqu'à ce que la condition soit fausse, voyons un exemple simple pour illustrer cela :

 local i = 1 tandis que var1 [i] imprime (var1 [i]) i = i + 1 end

Cette déclaration contrairement à la tandis que nous permet de répéter le code à l'intérieur de la condition jusqu'à ce qu'il soit vrai, où même ce code peut être exécuté au moins une fois puisque l'évaluation de la condition se fait à la fin, voyons un exemple :

 répéter la ligne = os.read () jusqu'à ce que la ligne ~ = "" imprimer (ligne)

Concernant les cycles itératifs pour, Lua en a deux variantes, la pour numérique et le générique pour. Regardons la syntaxe du numérique pour :

 pour var = exp1, exp2, exp3 finissent

Cette boucle exécutera quelque chose pour chaque valeur de var depuis exp1 jusqu'à exp2 en utilisant exp3 comme valeur pour augmenter ou diminuer var, si nous ne l'incluons pas Lua suppose par défaut que cela va un par un, voyons un exemple plus détaillé de ces cycles :

 pour var = 1, f (x) imprime (var) end pour var2 = 10,1, -1 imprime (var2) end

Comme nous le voyons, son application est assez simple et nous permet d'implémenter les cycles itératifs utiles dans nos programmes, voyons maintenant la syntaxe du générique pour:

 pour i, var in ipairs (array) do print (var) end

Ce que ce cycle fait, c'est utiliser la fonction qu'il nous donne Lua appel paires, qui est un itérateur de tableaux, où pour chaque itération i prend un indice, tandis que var obtient la valeur associée à cet indice.
Comme nous voyons les déclarations à l'intérieur Lua Ils ne diffèrent pas beaucoup des autres langages, cependant le langage ajoute cette simplicité supplémentaire pour nous donner un apprentissage beaucoup plus rapide de sa syntaxe et une utilisation beaucoup plus efficace. Avec cela, nous terminons ce didacticiel, où nous avons appris les affectations et les structures de contrôle au sein de Lua, ajoutant ainsi une autre couche de connaissances en ce qui concerne ce langage simple mais puissant.