Base du Langage LUA

 0
 0
Tps de lecture estimé:4 minutes 23 secondes

Voici une présentation rapide du language LUA.
Ce contenu est extrait de la page wikipedia

Généralités


Commentaires

En Lua, les commentaires débutent par -- et finissent à la fin de la ligne, comme en Ada. Si la première ligne commence par #! (shebang) elle est aussi traitée comme un commentaire. Les commentaires multilignes sont également disponibles avec la syntaxe

--[[...]]

Variables

Les variables peuvent contenir nil (la valeur nulle, vide), un booléen, une chaîne de caractères, un nombre, une table ou une fonction. Il existe aussi d'autres types comme userdata ou thread moins souvent rencontrés. Le type userdata est très pratique, il correspond à un objet C/C++ défini par l'utilisateur : il est donc possible de créer une structure C ou une classe C++, et d'utiliser des objets de ce type dans un script Lua, après avoir attaché à cet objet une métatable qui se charge d'appeler les fonctions de la classe C++. On peut donc imaginer de créer les classes métier de base d'un programme en C, et coder l'application elle-même en Lua, ce qui accélère considérablement son développement grâce aux outils de haut niveau fournis par le langage.

Par défaut, lorsqu'on déclare une variable, elle est globale à tout l'environnement d'exécution, sauf si elle est précédée du mot-clef local.

Les chaînes de caractères sont délimitées par des guillemets simples (') ou doubles ("), voire la marque de chaîne littérale

L'opérateur de concaténation de chaînes se représente par deux points (..).

Les fonctions

Les fonctions sont considérées comme des variables. Cela apporte une grande flexibilité : il est par exemple possible de créer des fonctions locales à une autre fonction, de passer une fonction comme paramètre d'une autre fonction (ou comme valeur de retour) ou de mettre des fonctions dans des tables. Si on affecte nil à une fonction (eg. print = nil), la fonction n'existe plus, n'est plus appelable.

Un avantage des fonctions en Lua est qu'elles peuvent prendre un nombre indéfini de paramètres mais aussi qu'elles peuvent retourner plusieurs valeurs.

Les tables, métatables

Les tables sont une structure Lua qui permet de stocker des variables indexées par une clef (comme en PHP par exemple). Les tables servent à beaucoup de choses en Lua. C'est par exemple la structure utilisée pour représenter des pseudo-classes et objets.

Les métatables sont des tables pour lesquelles on a associé une fonction à chaque opérateur de base (+, -, (), []...). Ce mécanisme est très proche de la redéfinition des opérateurs en C++. Par exemple, si la variable x contient une table associée à une métatable appropriée, l'appel de fonction x(arguments) sera valide car Lua cherchera alors dans la métatable comment traiter cet appel.

C'est ainsi qu'on peut implémenter l'héritage entre tables. Si un champ n'est pas trouvé lorsqu'il est demandé, Lua cherchera dans la métatable quelle table est parente et demandera à la table parente de fournir l'élément approprié.

Exemples


Condition

if condition1 and condition2 then
 -- instructions exécutées si les conditions 1 et 2 sont vraies
elseif condition1 then
 -- instructions exécutées si la condition 1 est vraie et la condition 2 est fausse
elseif condition2 then
 -- instructions exécutées si la condition 2 est vraie et la condition 1 est fausse
else
 -- instructions exécutées si les deux conditions sont fausses
end

Boucles

repeat
 -- code
until condition

et

while condition do
 -- code
end

ainsi que

for var = start, valend, step do
 -- code
end

ou

for var_1, ..., var_n in explist do
 -- code
end

Déclaration de fonctions

function mafonction(arg1, arg2, ...)
 -- code
 return résultat1, résultat2
end

ou

 -- code
 return résultat1, résultat2
end

Appels de fonction

res1, res2 = mafonction(var)

Blocs inconditionnels

Les blocs inconditionnels servent par exemple à déclarer des variables locales à ce bloc :

do
 local mavariable = "chaîne" -- déclaration de variable, optionnel
 -- code utilisant mavariable
end

Déclaration de table

  • Table à indices numériques consécutifs (premier indice : 1)

    a = { 5, "foo", [[C:\Lua\Lua.exe]], 'bar', 42 }
  • Table à indices explicites, indiqués entre crochets (les indices qui sont des chaines ayant la syntaxe d'une variable n'ont pas besoin de guillemets ni de crochets)

    a = { d = 5, [12] = "foo", ['chaîne avec espace'] = true }
  • Table stockant des variables complexes : autres tables, fonctions, références croisées...
    fonction = function (a, b) return (a + b) / a * b end
    t =
    {
    b =
    {
    -- Fonction comme clé
    [fonction] = 'Fonction !',
    -- Index numérique
    [5] = 42,
    -- Index chaîne simple (ie. syntaxe d'une variable)
    ls =  [[Valeur
    Multiligne]] ,
    -- Index chaîne quelconque
    [Expression rationnelle] = [[(?:\d{1,3}\.){3}\d{1,3}]],
    [ [[C:\Lua\Lua.exe]] ] = true,
    },
    -- Stockage d'une fonction
    f = function () return math.random(100) end,
    ff = fonction,
    -- Table comme clé
    [ { 'a', 'b' } ] = { "aa", "bb" },
    }
    -- Référence dans la table
    t.reference = t.a
    t[ { t.a, t.b } ] = t.f

Hello World

print('Hello World!')

Pour aller plus loin

Article précédent Article suivant