# Syntaxe générale ## Commentaires ```lua -- ceci est un commentaire simple ligne en lua -- en voici un autre --[[ ce commentaire peut s'étaler sur plusieurs lignes ]] ``` ## Opérateurs arithmétiques Les mêmes qu'en Python : `+, -, *, %, /`. Mais Lua ne connaît pas `//` et pour l'élévation à la puissance, Lua utilise l'habituel `^` et pas le `**` de Python. **Important :** Il ne doit pas y avoir une expression comme `2 + 3` sans rien. Il faut forcément envoyer ce résultat comme `x = 2 + 3` ou `print(2 + 3)` ou encore `= 2 + 3` ce qui en console affiche le résultat. ## Les blocs En Python, les blocs structurels commencent toujours par `:` et continuent tant que cours l'indentation. ```python # Exemple Python i = 0 while i < 10: i = i + 1 if i % 2 == 0: print(i) print("fini") ``` En lua, l'indentation n'est pas obligatoire. On l'utilise seulement pour plus de lisibilité. Le bloc se termine par le mot-clé `end`. ```lua -- Exemple Lua i = 0 while i < 10 do i = i + 1 if i % 2 == 0 then print(i) end end print("fini") ``` On peut écrire les instructions sur une même ligne pour peu qu'on les sépare par `;`. Mais c'est peu lisible. ```lua -- lua sans retours à la ligne i = 0; while i< 10 do i = i + 1; if i % 2 == 0 then print(i); end; end; print("fini") ``` ### Les chunks En lua, le concept de bloc est essentiel. On nomme chunk le bloc. On définit même un bloc générique : ```lua do -- faire quelque chose end ``` Comme on le dire plus loin, le chunk définit la portée des variables. Lorsque l'exécution du script en arrive au début d'un chunk, chaque fonction et chaque ligne est compilée puis l'exécution commence. ### chunk et portée des variables Tous les langages posent le problème de la portée des variables. Certaines variables seront accessibles de n'importe où dans le programme, elles sont *globales*, d'autre ne sont accessibles que depuis une portion limitée du programme, elles sont *locales*. Habituellement, ce sont les fonctions qui définissent les contextes locaux. Une variable définies dans une fonction est locale et visible seulement depuis l'intérieur de cette fonction. Ce n'est pas ainsi avec lua : * Pour lua, il faut préciser `local` pour rendre une variable locales. En l'absence de `local`, la variable sera globale. Comme on a intérêt à éviter au maximum les variables globales, on doit penser à déclarer les variables avec `local` aussi souvent que possible. * Les contextes locaux sont définis par les chunks. Une fonction est un chunk parmi d'autres. les boucles `while`, `for` et les tests `if` sont aussi des chunks et donc définissent des contextes locaux. Exemple : ```lua x = 5 if x < 10 then local x = 17 -- ce x n'existe que dans le if print(x) -- affiche 17 end print(x) -- affiche 5 ``` Dans cet exemple, il y a deux `x` différents, le `x` défini dans le test et l'autre. L'affectation `x = 17` n'a pas d'incidence sur le `x` défini avant le test et que l'on retrouve après la fin du test. ## Tests ```python # Bloc if en Python if x < 5: print("x inférieur à 5") elif x < 10: print("x entre 5 et 10") else: print("x supérieur à 10") ``` ```lua -- bloc if en lua if x < 5 then print("x inférieur à 5") elseif x < 10 then print("x entre 5 et 10") else print("x supérieur à 10") end ``` Vous pouvez noter que `elif` devient `elseif`, la présence ce `then` et de `end`. Autrement peu de différence. ### Opérateurs de comparaison Ce sont les mêmes qu'en Python : `==, <, <=, >=, >` mais il y a une différence : L'opérateur "différent de " en Python est `!=` et en Lua `~=`. ### Opérateurs logiques Comme Python, Lua utilise `and, or, not` qui fonctionne de la même façon séquentielle. ## Boucle non bornée On l'a vu plus haut, on retrouve la boucle `while` à ceci près que lua nécessite `do` et `end` : ```python # somme d'entiers en Python S = 0 i = 1 while i < 10: S += i i += 1 print(S) ``` ```lua -- somme d'entiers en Lua S = 0 i = 1 while i < 10 do S = S + i i = i + 1 end print(S) ``` Vous remarquez au passage que l'opérateur `+=` n'est pas défini en Lua. ### Répéter jusqu'à La boucle **répéter jusqu'à** est comme une boucle tant que inversée : la condition de la boucle tant que indique à quelle condition la boucle doit se poursuivre ; la condition de la boucle répéter jusqu'à indique à quelle condition la boucle s'arrête. Ce type de boucle est courante en programmation. Lua la possède, pas Python. Par exemple, problème mathématique classique, prenons une population de lapins qui commence à 1000 individus l'année 2020 et qui augmente de 3 % tous les ans. En quelle année la population dépassera-t-elle 2 000 individus ? *Il faut se souvenir que augmenter de 3 % revient à multiplier par 1,03.* ```lua pop = 1000 annee = 2020 repeat annee = annee + 1 pop = pop * 1.03 until pop > 2000 print(annee) ``` Comme déjà dit, Python n'a pas de boucle répéter jusqu'à, mais une boucle tant que fait aussi bien, il suffit d'inverser la condition : ```python pop = 1000 année = 2020 while pop <= 2000: année += 1 pop *= 1.03 print(année) ``` La boucle répéter jusqu'à n'est donc pas essentielle. Elle est simplement un peu plus naturelle dans certains cas mais là remplacer par une boucle tant que ne pose aucune difficulté. Au passage, vous noterez que Python n'est pas gêné par l'accent dans le nom de la variable `année`. Python gère complètement l'Unicode. En Lua, pas d'accents ou de caractères spéciaux dans les noms de variables, il faut se limiter aux caractères ASCII. ### break Comme Python, Lua dispose du mot-clé `break` qui permet d'interrompre une boucle. Toutefois, le `break` doit se trouver en fin de bloc. Par exemple, un programme cherchant si un nombre N est premier : ```lua -- le nombre N est-il premier ? d = 2 while d < N do if N % d == 0 then break -- pas d'instruction dans le bloc if après le break ! end d = d + 1 end if d == N then print("N est premier.") else print("N n'est pas premier.") end ``` ## Boucle bornée : boucle pour En programmation, la boucle **pour** se présente sous deux formes :. 1. POUR indice ALLANT DE a À b... 2. POUR item DANS ensemble La forme 1. est la plus courante. On la rencontre en C, Java, Javascript... Elle est présente en Lua. La forme 2. est aussi présente en Lua et c'est la forme utilisée en Python : `for .. in ..` Le `for .. in..` suppose d'avoir un ensemble à parcourir. Nous y reviendrons quand nous parlerons de tables. Ici nous nous contenterons de la première forme. Par exemple, on veut afficher les carrés des entiers de 1 à 10. ```python # Python : crée une énumération avec range for i in range(1, 11): print(i**2) ``` ```lua -- lua, boucle for classique for i = 1, 10 do print(i^2) end ``` À noter que sous cette forme, la boucle `for` est un simple raccourci d'une structure totalement équivalente que l'on obtiendrait avec `while` : ```lua -- lua, équivalent avec while i = 1 while i <= 10 do print(i^2) i = i + 1 end ``` L'utilisation de `for` revient à créer automatiquement l'initialisation `i=1` et l'incrémentation `i = i + 1`. En programmation, seuls `if` et `while` sont vraiment indispensables. `for` peut être qualifié de *sucre syntaxique*, c'est à dire une syntaxe plus agréable mais non essentielle.