Syntaxe générale

Commentaires

-- 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.

# 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.

-- 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 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 :

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 :

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

# 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")

-- 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 :

# somme d'entiers en Python
S = 0
i = 1
while i < 10:
    S += i
    i += 1
print(S)

-- 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.

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 :

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 :

-- 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 : crée une énumération avec range
for i in range(1, 11):
    print(i**2)

-- 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, é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.