Quelques notions de Lua pour commencer avec NodeMCU Lua

Le langage LUA est largement utilisé depuis plusieurs années comme langage de script pour étendre des jeux. Il s'interface assez facilement avec le langage C, ce qui permet d'embarquer de l'"embarquer" dans une application. Tout comme Java, il utilise une machine virtuelle qui peut être suffisamment légère pour être embarqué dans une micro-puce comme l'ESP8266. LUA n'est pas un langage objet mais l'utilisation des fonctions permet de s'en approcher.

La documentation officielle en anglais se trouve à l'adresse http://www.lua.org/docs.html. 

Nous verrons ici les notions de bases classiques pour écrire de petits programmes.

Les variables

Le langage LUA n'est pas fortement typé. Les variables peuvent être utilisées à la volée sans avoir besoin d'être déclarées. On retrouve les types habituels:

- les nombres (entiers et réels) : 

entier=2, reel=0.5

- les chaînes de caractères : 

chaine="Bonjour"

- les tables : 

tableau={10, 20, 30}

- les tables dictionnaires : 

dictionnaire={nom="Dupont", prenom="Alain"}

- les booléens : 

vrai=true

faux=false

- la valeur vide : 

vide = nil

Vous pouvez afficher le contenu de ces variables à l'aide de la fonction print.

> print(entier)

2

> print(reel)

0.5

> print(chaine)

Bonjour

> print(tableau[1])

10

Notez que l'indexation du tableau commence à 1, pas à zéro comme en C ou en Java.

> print(dictionnaire.nom.." ".. dictionnaire.prenom)

Dupont Alain

Notez que la concaténation de chaînes se fait à l'aide de ".." et non de "+" comme dans d'autres langages.

Les types des variables peuvent être obtenus à l'aide de la fonction type.

> print(type(chaine))

string
> print(type(entier))
number
> print(type(vrai))
boolean
> print(type(tableau))
table

> print(type(dictionnaire))
table

Les nombres

Les nombres s'utilisent de manière assez classique. Sur l'ESP8266, la librairie math n'est cependant pas installée, ce qui limite aux opérations de base.
> =1+2*3
7
Pour convertir une chaîne de caractères en nombre:
> =tonumber("12345")

 12345

Lua convertie automatiquement des chaînes en nombres.
> ="10"+31
41

Les chaînes

Les chaînes peuvent se déclarer de 3 manières.
> = "bonjour"
bonjour
>= 'bonjour '
bonjour
>= [ [ bonjour ] ]
bonjour

Cette dernière notation permet également de définir une chaîne sur plusieurs lignes.
> =[[ceci est
>> une chaine
>> sur plusieurs lignes]]
ceci est
une chaine
sur plusieurs lignes

Voici quelques fonctions utilisables sur les chaînes de caractères:
- La concaténation : ".."
> ="Hello ".."World"
Hello World
> =("Il est "..10)..(" heures et "..25).." minutes"
Il est 10 heures et 25 minutes

Les chaînes et les codes ascii.
> =string.byte("A plus tard", 2)
32
> =string.char(65, 32, 66, 32, 67, 32, 68, 32, 69)
A B C D E

La longueur d'une chaîne s'obtient à l'aide de l'opérateur "#"
> =#Bonjour
7

Les autres fonctions utilisables sur les chaînes sont :
string.char(0, 0, 255) => crée une chaîne de 3 caractères à partir de bytes.
string.len(s) => renvoie la longueur de la chaîne de caractères
string.sub(s, debut, fin) => renvoie une sous chaîne entre le début et la fin.(commence à 1)
string.format(format, s1, ...) => renvoie une chaîne formatée

Les blocs d'instructions

Les blocs se terminent par le mot clef "end". Il n'y a pas de mot clef de début de bloc comme en Pascal ("begin") ou en Java, C, C++ ou C# ("{}"). Les blocs sont utilisés pour exécuter des commandes conditionnelles ou répétitives.

Les commandes conditionnelles

Une condition peut être définie de plusieurs manières.

if <condition> then -- Si condition alors actions
    <actions>
end

if <condition> then -- Si condition alors actions1
   <actions1>
else -- sinon actions2
   <actions2>
end

if <condition1> then -- Si condition1 alors actions1
   <actions1>
elseif <condition2> then -- sinon, si condition2, alors actions2
    <actions2>
elseif <condition3> then -- sinon si conditions3, alors actions3
    <actions3>
else -- Sinon actions4
    <actions4>
end

Les boucles

Les boucles permettent de répéter une action plusieurs fois. Les trois structures de boucles sont:
while <condition> -- Tant que condition est vraie, répéter actions
   <actions>
end

repeat -- Répéter les actions jusqu'à ce que la condition soit vraie
   <actions>
until <conditions>

for <variable>=start, end, increment -- Boucle for avec un début, une fin et un incrément
   <actions>
end

for <variable> in <table> -- Pour chaque élément du tableau, exécuter les actions
   <actions>
end

Les fonctions

Les fonctions ont la particularité de pouvoir renvoyer plusieurs résultats.
function <nom>(paramètre 1, paramètre 2, ..., paramètre n)
   <actions>
   return resultat1, résultat2
end

Pour appeler cette fonction,

resultat1, resultat2 = <nom>(paramètre 1, paramètre 2, ..., paramètre n)

Les fonctions peuvent également être stockées dans des variables ou des tableaux. Cette notion issue des langages d'Intelligence Artificielle comme le LISP et également utilisables en Java s'appelle les lambda fonctions. Cette définition de fonction est exactement la même que la précédente.
name = function(parametre 1, parametre 2, ..., parametre n) 
   <actions>
   return resultat1, resultat2
end

Mise dans un tableau nommé, les fonctions peuvent ainsi être l'équivalent des méthodes dans les langages objets. Il n'y a pas réellement de notion de classe, mais on peut ainsi avoir des instances d'objets ou des prototypes (exemplaire unique) qui peuvent être dupliqués.
Exemple :
dupont=
{
   prenom="Pierre",
   nom="Dupont",
   anneeDeNaissance=1970,
   age=function(current)
      return  current - dupont.anneeDeNaissance
   end
}