辣椒蟹吃什么

Lua
Date de première version	1993
Paradigme	Multi-paradigme : procédural, orienté objet à prototype et fonctionnel
Auteur	Luiz Henrique de Figueiredo, Roberto Ierusalimschy et Waldemar Celes
Dernière version	5.4.8 (4 juin 2025)
Typage	dynamique, faible
Influencé par	BASIC, C, C++
A influencé	Micro Lua DS
Implémentations	Lua, LuaJIT, LLVM-Lua, LuaCLR, Nua, Lua Alchemy, MicroLua, Mochalua, Jill, luaj, LuaRT
écrit en	C
Système d'exploitation	Multiplate-forme
Licence	Licence MIT
Site web	lua.org
Extension de fichier	lua, luna, lunaire et anair

Lua est un langage de script libre, réflexif et impératif. Il intègre un ramasse-miettes, et il est con?u de manière à pouvoir être embarqué dans d'autres applications pour les étendre.

Lua (du portugais : Lua [?lu.?], au Brésil : [?lu.a], signifiant ? Lune ?), a été développé en 1993 par Luiz Henrique de Figueiredo, Roberto Ierusalimschy (en) et Waldemar Celes, membres du groupe de recherche TeCGraf, de l'université pontificale catholique de Rio de Janeiro au Brésil.

L'interpréteur Lua est écrit en langage C ANSI strict, ce qui le rend compilable sur beaucoup de systèmes. Il est aussi très compact, la version 5.0.2 n'occupant que 95 ko à 185 ko selon le compilateur utilisé et le système cible. L’existence d’interfaces entre C et de nombreux langages facilite l’intégration de Lua dans la plupart des projets.

Sa compacité et son extensibilité le font particulièrement apprécier pour l'embarqué, le développement réseau et les jeux vidéo.

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

Une variable peut contenir un booléen, une cha?ne de caractères, un nombre (pas de différence entre entier et flottant), une table ou une fonction. Il existe aussi d'autres types comme userdata ou thread, moins souvent rencontrés. Le type userdata 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 C/C++ appropriées. On pourrait donc imaginer, par exemple, 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érerait son développement grace aux outils de haut niveau fournis par le langage.

Une variable non définie a la valeur nil. Affecter nil à une variable revient à la supprimer.

En interne on peut aussi rencontrer des proto, une sorte de prototype de fonction: le bytecode de cette fonction est chargé mais ce dernier n'a pas encore été exécuté. On rencontre les proto quand un fichier est chargé (compilé) mais pas exécuté ou bien avec des closures.

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

Les cha?nes

Les cha?nes de caractères sont délimitées par des guillemets simples (') ou doubles ("), voire par des délimiteurs littéraux [[ ?de niveau n? où n est un certain nombre de signes =. Une cha?ne délimitée ainsi ne s’arrête qu’au délimiteur fermant de même niveau.

a = "a\tbc"        -- Traduit \t en tabulation
b = 'a\tbc"\''     -- Traduit \t en tabulation et \' en guillemet littéral.
c = [[...]]        -- Multiligne, n’interprète aucune séquence \
d = [=[ ... ]=]    -- Multiligne, peut contenir des [[, des -- etc.
e = [==[ ... ]==]  -- Multiligne, peut contenir des [=[, des [[, des --, etc.

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. On peut donc en créer dans d'autres fonctions, en passer comme paramètre ou comme valeur de retour d'une autre fonction, ou en mettre comme clé ou comme valeur dans une table.

En Lua, une fonction peut recevoir un nombre quelconque de paramètres, et renvoyer un nombre quelconque de valeurs.

Déclarer une fonction

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

ou

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

Le return doit être la dernière instruction avant end. Si nécessaire, on le met dans un bloc inconditionnel.

Appeler une fonction

Les paramètres non-précisés à l’appel sont considérés comme nil. Les valeurs renvoyées en trop sont ignorées.

res1, res2 = mafonction(var)

Les tables, métatables

En Lua, la structure stocke des valeurs indexées par une clé (comme en PHP par exemple). C’est la structure centrale du langage pour représenter tous les objets complexes.

Index et valeurs

Une table peut, entre autres, être utilisée comme :

• Une liste (par exemple la syntaxe {a,b,c,…} crée une liste débutant à l’index 1). L’opérateur # donne alors la longueur de la liste.
• Une hashtable (pouvant faire office de structure), qui peut prendre en clé et en valeur tout type de variable (sauf nil).

Les index et les valeurs peuvent être de tout type (l’opérateur # fonctionne toujours mais n’a vraiment de sens que pour les listes)

Par convention, on parcourt une liste avec l'itérateur ipairs et une hashtable avec l'itérateur pairs.

La clé nil est interdite. Affecter nil à un index est permis mais revient à le supprimer. Ainsi a={nil,"x",nil,"y"} équivaut à a={[2]="x",[4]="y"}. L’opérateur de longueur # n’a alors plus de sens, l’itérateur pairs saute les nil, et l’itérateur ipairs s’arrête au premier nil.

Métatables et objets

Les tables facilitent la programmation dans un style objet, notamment grace à deux sucres syntaxiques:

• objet.clef équivaut à objet["clef"]
• objet:f() passe à objet.f() un argument caché self=objet

Quant aux métatables, introduites dans Lua 2.1, ce sont des tables que l’on associe à un objet, pour introduire une sorte d’héritage. En effet, si un objet x est associé à la métatable m, et si x[c] n’existe pas, Lua cherche m[c] à la place.

Les métatables permettent également une sorte de surcharge des opérateurs, car Lua y cherche les fonctions __add(), __sub(), __call(), __index() … pour exécuter les opérations +, -, (), []….

L’objet Vector ci-dessous illustre ces notions avec un constructeur, une méthode, et deux opérateurs redéfinis:

local Vector = {}
Vector.__index = Vector -- Où chercher les index absents

function Vector:new(x, y, z)    -- Constructeur
  -- Le ":" passe "self" en premier, qui référence "Vector"
  return setmetatable({x = x, y = y, z = z}, self)
end

function Vector:magnitude()     -- Exemple de méthode
  return math.sqrt(self.x^2 + self.y^2 + self.z^2) -- "self" est passé grace à ":"
end

function Vector.__add(a,b)  -- Définit "+"
  return Vector:new(a.x+b.x, a.y+b.y,a.z+b.z)
end

function Vector.__unm(a)    -- Définit la négation "-"
  return Vector:new(-a.x,-a.y,-a.z)
end

local v = Vector:new(0, 1, 0) -- Crée un vector
print(v:magnitude())          -- Appel de méthode (sortie: 1)
print(v.x, v.y, v.z)          -- Accès aux membres (sortie: 0 1 0)
w = -(v + v)                  -- + et - définis par __add() et __unm()
print(w.x,w.y,w.z)            -- Résultat (sortie: 0 -2 0)

Déclaration de table

Pour créer une table à indices numériques consécutifs (démarrant à 1):

a = { 5, "foo", [[C:\Lua\Lua.exe]], 'bar', 42 }

On peut donner explicitement les indices de la table à créer, entre crochets. Les indices cha?nes semblables à un nom de variable peuvent se passer de guillemets et de crochets :

a = { d = 5, [12] = "foo", ['cha?ne avec espace'] = true } -- comme ["d"]=5

Dans une assignation, la valeur est copiée si c’est un nombre, une cha?ne ou un booléen. Sinon seule la référence est copiée. En particulier, si la variable a est une table et si on assigne a à la variable b, alors toute modification dans la table a est visible dans b, et vice-versa :

local a = {1,"b",3}
local b = a
a.foo = "bar"
print(b.foo) -- bar
-- b et a ont la même référence

L’exemple qui suit est une table stockant des variables complexes : autres tables, fonctions, références croisées…

De même que ci-dessus, si un indice n’est ni un nombre, ni une cha?ne de caractères, ni un booléen, c’est une référence vers la variable concernée :

 fonction = function (a, b) return (a + b) / a * b end
t =
{
	b =
	{
		-- Fonction comme clé
		[fonction] = 'Fonction !', -- la référence à fonction sert de clé
		[5] = 42,                  -- Index numérique
		-- Index cha?ne simple (c.-à-d. la 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,
	},
	f = function () return math.random(100) end, -- clé "f" référen?ant une fonction anonyme.
	ff = fonction, -- clé "ff" référen?ant la fonction globale "fonction"
	-- Référence de table anonyme comme clé: valeur difficilement accessible
	[ { 'a', 'b' } ] = { "aa", "bb" }, -- (i)
}
-- Référence dans la table
t.self = t -- Référence à soi-même
print(t[ { 'a','b'} ]) -- nil car la référence de la nouvelle table { 'a','b' } 
                       -- n'est pas celle de la table { 'a','b' } qui sert de clé en (i)

Boucles, blocs et conditions

Condition

La structure if ... then ... elseif ... else ... end est semblable à celle de la plupart des langages

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

Les opérateurs logiques sont and, or et not.

Les booléens sont true et false, mais les expressions conditionnelles concernent tous les types: une condition est fausse si elle vaut nil ou false, et vraie sinon.

for i,v in ipairs({true, false, 1, "", "0", 0, "true", "false"}) do
  if (v) then print(type(v), v, " est vrai") else print(type(v), v, " est faux") end
  -- boolean true     est vrai
  -- boolean false    est faux
  -- number  1        est vrai
  -- string           est vrai -- Pas comme dans awk
  -- string  0        est vrai --
  -- number  0        est vrai -- Eh oui! pas comme en C
  -- string  true     est vrai
  -- string  false    est vrai -- "false" est une string, pas le booléen false
end

Les opérateurs logiques and et or appliquent une logique de "court-circuit", en renvoyant le premier de leurs opérandes qui suffit à savoir si la formule est vraie ou fausse.

-- Illustration du court-circuit pour ?and? et ?or?
print("un" or "deux" or "trois") -- "un" : ?or? arrête au premier terme vrai et le renvoie
print(nil or false or "dernier") -- "dernier" ... sinon il donne le dernier terme.
print ("un" and nil and "trois") -- "nil" : ?and? arrête au premier terme faux et le renvoie
print ("un" and "deux" and "trois") -- "trois" : ... sinon il donne le dernier terme.
-- Avec des booléens cette logique équivaut aux formules classiques
print(false or true or false)   -- true
print(true and true and false)  -- false

Boucles

Les structures while et repeat rebouclent tant qu’une condition est vraie. La boucle repeat exécute au moins une fois son corps car elle teste sa condition à la fin.

repeat
 -- code
until condition

while condition do
 -- code
end

Une boucle for affecte successivement des valeurs données par un départ, une arrivée et un incrément, ou par un énumérateur.

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

for var_1, ..., var_n in explist do
 -- code
 if condition_arret then
     -- autre code
     break -- doit toujours être suivi d’un "end"
 end
 -- code
end

Le dernier exemple montre une instruction break pour quitter la boucle. Elle doit toujours figurer avant un end, ce qui demande parfois de créer un bloc inconditionnel.

Blocs inconditionnels

Les blocs inconditionnels servent par exemple à limiter la visibilité des variables locales :

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

Les fonctions standard

Les fonctions mathématiques

La valeur math.pi est le nombre pi.

print(math.pi) --> Affiche dans la console la valeur de pi (3.1415926535898)

La fonction math.min(liste) retourne le plus petit nombre contenu dans une liste

print(math.min(6, 4, 2, 9, 1)) --> Affiche 1 dans la console étant donné que 1 est le plus petit nombre de la liste.

La fonction math.max(liste) retourne le plus grand nombre contenu dans une liste

print(math.max(4, 6, 7, 9, 1)) --> Affiche 9 dans la console étant donné que ce nombre est le plus grand de sa liste.

La fonction math.floor(x) retourne la partie entière de x.

print(math.floor(1.5)) --> Retourne dans la console le nombre 1
print(math.floor(1.5 + 0.5)) --> Retourne dans la console le nombre 2

La fonction math.abs(x) retourne la valeur absolue de x.

print(math.abs(-100)) --> Retourne dans la console le nombre 100.

La fonction math.pow(x, y) retourne x à la puissance de y. On peut aussi utiliser l'expression x^y

print(math.pow(6, 8)) --> Retourne dans la console le nombre 1679616.
-- On peut également utiliser:
print(6^8)

La fonction math.random(x, y) retourne un nombre aléatoire entre la valeur x et la valeur y.

local x = 1
local y = 10

print(math.random(x, y)) --> Retourne dans la console un nombre entier aléatoire entre 1 et 10.

La fonction math.sqrt(x) retourne la racine carrée de x.

local x = 6
print(math.sqrt(x)) --> Retourne la racine carrée de x(6) donc 2.4494897427832.

Les fonctions os

La fonction os.time() retourne le nombre de secondes entre le 1^er janvier 1970 à 00:00 et la seconde à laquelle vous appelez la fonction.

print(os.time())

La fonction os.date() retourne le jour, le mois, le numéro du mois, l'heure, les minutes, les secondes et l'année à laquelle vous êtes quand vous appelez cette "fonction"

print(os.date()) --> Retourne Thu Jul 1 14:52:59 2021

La fonction os.clock() retourne le temps écoulé en seconde depuis que Lua a été lancé.

print(os.clock()) --> Retourne dans la console 853312.913685

La fonction type

La fonction type(x) donne le type de x sous forme de cha?ne.

local a = "Bonjour"
local b = 5
local c = true
local d

print(type(a)) --> Affiche "string" car la variable est de type string.
print(type(b)) --> Affiche "number" car la variable est de type number.
print(type(c)) --> Affiche "boolean" car la variable est une valeur booléene
print(type(print)) --> Affiche "function" car print est une fonction.
print(type(d)) --> Affiche "nil" car la variable d ne contient pas de valeur.

Les fonctions table

En lua, il existe 9 fonctions table.

La fonction table.insert(x, y, z) insère une valeur y dans un tableau x. On peut lui indiquer la position d’insertion avec un argument z. Si z n'est pas donné, la valeur est mise en dernière position de la table.

local tableau = {"je", "suis", "un", "utilisateur", "du"}
table.insert(tableau, "wiki") --> Insert dans la variable tableau enla valeur wiki. Le troisième argument pour donner la position n'est pas donné donc la valeur se positionnera en dernière place du tableau.

La fonction table.remove(x, y) retire du tableau x la valeur qui se trouve en position y.

local tableau = {"je", "suis", "un", "faux", "utilisateur"}

table.remove(tableau, 4) --> Retire la valeur "faux" du tableau qui était en {{4e|position}}.
-- Il faut conna?tre la position de la valeur à retirer. Sinon, on peut utiliser pairs() dans une boucle.

La fonction table.sort(x) permet de trier et modifier la position des éléments du tableau x.

local tableau = {6, 4, 5, 3, 2, 1}
table.sort(tableau) --> Va venir trier les valeurs du tableau et le modifier en {1, 2, 3, 4, 5, 6}

La fonction table.concat(x, y) concatène les valeurs d'un tableau pour former une chaine de caractères. Le y, facultatif, sert à séparer les valeurs.

local tableau = {"un", "renard", "caché", "dans", 1, "arbre"}
local concatTableau = table.concat(tableau)

print(concatTableau) --> Retourne dans la console la valeur unrenardcachédans1arbre

Voici un exemple d’utilisation du séparateur y:.

local tableau = {"un", "renard", "caché", "dans", 1, "arbre"}
local concatTableau = table.concat(tableau, " | ")

print(concatTableau) --> affiche: un | renard | caché | dans | 1 | arbre. L'argument " | " a été ajouté entre chaque valeur transformée.

Les fonction table.foreach(x, z) et table.foreachi(x, y) sont obsolètes depuis la version 5.1 de lua et doivent être remplacées par pairs() et ipairs(). Voir ci-dessous. La fonction table.getn(x) donne la taille d'un tableau x.

local tableau = {"un", "renard", "gentil"}
local longueur = table.getn(tableau) -- à remplacer par l’opérateur #tableau depuis lua 5.1

print(longueur) --> Retourne dans la console la longueur du tableau "tableau" donc 3.

Les fonctions strings

Les fonctions ?string.?, au nombre de 15, opèrent sur les variables de type string.

Le string.find(x, y) recherche des caractères y dans le string x. Il renvoie nil si rien n’est trouvé. Sinon il indique à partir de quel emplacement les caractères recherchés ont été trouvés.

local variable = "Bonjour, je m'appelle Lua."
local find = string.find(variable, "our")

if find then -- Si find ne vaut pas nil, alors la cha?ne est trouvée.
    print(find) -- Alors find donne l’index du premier caractère de la cha?ne trouvée (ici 5).
end

On peut aussi ajouter un argument z pour commencer la recherche à une certaine position.

local MA_VARIABLE = "Je suis quelqu'un qui suis une autre personne."
local resultat = string.find(MA_VARIABLE, "is", 17)

if resultat then -- Si "is" est trouvé au caractère 17 ou après, alors ...
    print(resultat) -- resultat contient la position du premier caractère trouvé (ici 25) 
end

Le string.byte(x, y, z) renvoie le code numérique des caractères (Code ASCII) de la string x.

local MA_VARIABLE = "Je suis une gentille personne"
local RESULTAT_ASCII = string.byte(MA_VARIABLE)

print(RESULTAT_ASCII) --> Retourne dans la console le résultat de la conversion de la string en code numérique ASCII

On peut aussi utiliser l'argument y pour définir un début de conversion ainsi que l'argument z pour définir la fin de conversion (numéro de caractère).

local MA_VARIABLE = "Je suis une gentille personne"
local RESULTAT_ASCII = string.byte(MA_VARIABLE, 1, 10) --> Retourne la conversion du caractère 1 à 10 de la string

print(RESULTAT_ASCII) --> Retourne dans la console le résultat de la conversion en ASCII du caractère 1 à 10 de la string.

Le string.char(x) convertit le code numérique x qui est en code ASCII en caractères normaux.

local ASCII_CODE = 74
local RESULTAT = string.char(ASCII_CODE)

print(RESULTAT) --> Retourne dans la console la conversion du code numérique ASCII en caractères numériques (de la variable ASCII_CODE)

Le string.dump(x) convertit la fonction x en une représentation binaire utilisable par la fonction loadString(y).

function demonstration()
    print("Lancement de la fonction")
end

local dumped = string.dump(demonstration)
assert(loadstring(dumped)) ()

--> Retourne dans la console "Lancement de la fonction."

Le string.format() renvoie une chaine de caractères formatée.

print(string.format("Je suis %s, j'adore les %s, et j'aime le nombre %i", "gentil", "bananes", 15))
--> Je suis gentil, j'adore les bananes, et j'aime le nombre 15

--> %s permet de rajouter des strings
--> %i permet de rajouter des nombres

Le string.gmatch(x, y) renvoie une sous-cha?ne de la cha?ne principale x.

for i in string.gmatch("Je suis quelqu'un de gentil", "%a+") do
	print(i)
end

--> Je
--> suis
--> quelqu
--> un
--> de
--> gentil

Le string.gsub(x, y, z) remplace les mots y d'une string x par un autre mot z.

print(string.gsub("Je suis une personne", "une personne", "un zombie")) -- string.gsub(x(la string), y(mot à remplacer), z(mot qui remplace))

--> Je suis un zombie

Le string.upper(x) renvoie le texte d'une string x en changeant les minuscules en MAJUSCULES (sauf caractères spéciaux).

local MA_STRING = "Je suis un éléphant Rose"
print(string.upper(MA_STRING))

--> JE SUIS UN éLéPHANT ROSE

Le string.lower(x) renvoie le texte d'une string x en changeant les MAJUSCULES en minuscules.

local MA_STRING = "JE SUIS QUELQU'UN"
print(string.lower(MA_STRING))

--> je suis quelqu'un

Le string.reverse(x) retourne le texte d'une string x en inversant la cha?ne de caractères.

local MA_STRING = "je suis un scripter"
print(string.reverse(MA_STRING))

--> retpircs nu sius ej

Le string.sub(x, y, z) renvoie la sous-cha?ne de x formée des caractères allant des indices y à z inclus (ou à la fin si z est absent). Si y ou z est négatif, la position est comptée à partir de la fin de la cha?ne x.

local MA_STRING = "je suis un scripter"
print(string.sub(MA_STRING, 1, 7))   --> je suis
print(string.sub(MA_STRING, -2))     --> er
print(string.sub(MA_STRING, -5, -1)) --> ipter

Le string.rep(x, y) concatène y fois le contenu de la string x.

local MA_STRING = "je suis "
print(string.rep(MA_STRING, 5))

--> je suis je suis je suis je suis je suis

Le string.match(x, y, z) renvoie une sous-cha?ne de caractères de la string x conforme au motif indiqué en y, et en cherchant à partir du caractère z (qui est facultatif).

local MA_STRING = "Je suis un scripter"
print(string.match(MA_STRING, "s..."))         --> suis
print(string.match(MA_STRING, "s...", 12))     --> scri

La fonction pairs()

La fonction pairs(x) énumère les index et les valeurs d'un tableau x. Elle replace table.foreach(), obsolète depuis Lua 5.1. A chaque itération, pairs(x) renvoie un index et la valeur associée à cet index dans le tableau. On prend souvent les noms de variables i et v: ainsi dans ? for i, v in pairs(x) do …?, i est un index dans x, et v est la valeur x[i].

local tableau = {"premier", "second", "troisième", "quatrième", "cinquième"}

for i, v in pairs(tableau) do
    print(i, v)
end

--> Résultat dans la console:
-- 1 premier
-- 2 second
-- 3 troisième
-- 4 quatrième
-- 5 cinquième

On peut aussi utiliser pairs() pour rechercher et retirer une valeur d'un tableau:

local tableau = {"un", "deux", "trois", "quatre", "cinq"}

for index, value in pairs(tableau) do
    if value == "trois" then
        table.remove(tableau, index) -- Retire du tableau la valeur trois.
        break -- Arrêt de la boucle.
    end
end

La fonction pcall()

La fonction pcall() sert à capturer les erreurs qui surviennent dans une fonction. Dans ce cas, pcall() empêche l’arrêt du script et fournit les informations sur l’erreur.

 pcall(function()
	print(table.find("s")) --> est une erreur.
	print("Salut")
end)

print("Je suis quelqu'un de gentil")

--> Dans la console:
-- Je suis quelqu'un de gentil

La fonction pcall() renvoie deux valeurs qui renseignent sur une erreur éventuelle:

local success, err = pcall(function()
	print(table.find("s")) --> est une erreur.
	print("Ca marche")
end)

print("Je suis quelqu'un de gentil")

if not success then -- Faute de succès, informer sur l’erreur
    print(err)
end

--> Dans la console:
-- Je suis quelqu'un de gentil
-- Script:2: invalid argument #1 to 'find' (table expected, got string)

Extensions de Lua avec l’API C

Comme expliqué dans PIL, la communication entre Lua et un programme C utilise une pile pour surmonter deux difficultés:

• l’allocation de mémoire : elle est manuelle en C, alors que Lua a son ramasse-miettes. Les objets sont épargnés par le ramasse-miettes tant qu’ils sont sur la pile.
• les types de données: statiques en C, dynamiques en Lua. l’API C offre notamment des fonctions de conversion entre les valeurs sur la pile et les types du C.

L’API C gère aussi la persistence des données par deux mécanismes:

• un registre (qui permet à toutes les fonctions C de partager des informations)
• les "upvalues" (valeurs de contexte que l’on peut associer à une fonction C). Cela permet entre autres à un programme C de prendre une seule fonction C pour en tirer plusieurs fonctions LUA -- des closures -- qui ne diffèrent que par leur contexte. L’exemple classique est celui des fonctions de comptage dont les compteurs doivent être indépendants.

Exemples

Hello World

print('Hello World!')
----------------------------
io.write("Hello World!")

Help

Fonction donnant le type d’un objet, et les indices, types et valeurs de ses éléments si c’est un objet table. Peut servir comme aide-mémoire des fonctions de bibliothèque io, table, string, etc.

function help(o)             -- essayer help(io), help(table), …
  local t = type(o)          -- Type sous forme de cha?ne
  print("Type:", t)
  if (t=="table") then
    local i,v
    for i,v in pairs(o) do   -- Fonction d’itération pairs
      print(i,type(v),v)     -- Ex: ?stdin userdata  file (00007FF96219F490)?
    end
  end
end

Usages

Consoles

Lua a été embarqué dans la PlayStation Portable de Sony, grace au programme Lua Player, et plus récemment Lua Player HM et Lua Player Euphoria qui permettent de lire des applications écrites avec Lua afin d'étendre les capacités de la console. Viendra plus tard l'XtreamLua Player, destiné à la création de jeux vidéo. Une modification (non officielle) du micrologiciel de la PSP permettait de lancer des programmes non-signés par Sony d'où la création d'un interpréteur Lua adapté pour la PSP.

Lua Player Euphoria reprend la syntaxe du Lua Player original et exécute le script à une vitesse fulgurante comparé au Lua Player HM. Cependant, Lua Player Euphoria est moins complet que son homologue plus ancien.

Lua Player One, un des derniers Lua Player mis à jour pour PSP, est un Lua Player développé au sein d'une communauté de développeurs espagnols ; il permet, entre autres, de gérer la 3D sur PSP. Un jeu de mini-golf dans l'espace a été développé à l'aide de cet outil.

Lua Player Plus (LPP) est sorti sur PlayStation Vita le 16 ao?t 2015. Ce Lua Player permet de créer des jeux pour la console.

Lua est inclus dans la console de poche open-source Pocket Chip (projet Kickstater). En effet cette dernière embarque le programme de console virtuel Pico-8 qui permet de jouer et de créer des jeux en Lua.

Extensions de jeux vidéo

Parmi les jeux vidéo de bac à sable qui l'utilisent figurent Garry's Mod, Roblox, Core, Stormworks (en) et Minecraft. Pour ce dernier, ComputerCraft, un mod du jeu Minecraft, utilise Lua pour concevoir des programmes graphiques ou consoles et des ? robots ? autonomes à l'intérieur du jeu, permettant d'automatiser de nombreuses taches répétitives ; Minetest, un jeu sandbox sous licence LGPL similaire à ce dernier, utilise Lua comme langage pour l'écriture d'extensions et à l'intérieur même du jeu (via certains modes) via la programmation de microcontr?leur ou de FPGA.

Il existe également un moteur de jeu utilisant Lua comme langage de programmation (une sorte de Pygame pour Lua) : L?VE.

Beaucoup d'autres jeux vidéo l'utilisent, comme World of Warcraft de Blizzard Entertainment, Far Cry (et le moteur CryEngine en général) de Crytek Studios, le logiciel multijoueurs de GTA:SA Multi Theft Auto, SimCity 4 et Natural Selection 2 de Unknown Worlds Entertainment (qui a entre autres développé Decoda, un IDE pour Lua). Enfin, certains scripts de Zoo Tycoon 2 (Blue Fang Games) sont également présents sous des formes non compilées dans les fichiers du jeu. The Binding of Isaac: Afterbirth+ est un DLC pour le jeu The Binding of Isaac: Rebirth qui permet le support de mods écrits en Lua.

Lua sert aussi dans jeux comme : Minetest, Transformice, Roblox, Onset, Multi Theft Auto (mod multijoueur de Grand Theft Auto: San Andreas), FiveM (mod multijoueur de Grand Theft Auto V), Factorio, Project Zomboid, nanos world,Balatro ainsi que les moteurs de jeu vidéo tels que le SourceEngine, L?VE, Solarus ou encore les Fantasy consoles, tel que Pico-8.

Réseau et Embarqué

Au niveau réseau, Lua sert comme hook sur Apache, Lighttpd (par défaut), Nginx (via OpenResty), dans les routeurs Cisco, dans l'analyseur de paquets Wireshark,

La compacité de Lua est très appréciée dans des systèmes embarqués tels qu'OpenWrt.

Le PABX Asterisk (autocommutateur téléphonique privé) propose Lua comme alternative pour étendre son plan de numérotation.

L'antispam Rspamd utilise également Lua pour son interface de programmation.

Autres logiciels

Lua est également utilisé pour l'extension des capacités du lecteur multimédia VLC, dans les gestionnaires de fenêtres EFL Edje d'Enlightenment, dans NeoVim pour sa configuration, ainsi que Awesome (comme langage de configuration et de script).

MediaWiki et les sites Wikimedia utilisent Lua comme langage de script pour les modèles (appelés modules).

Le logiciel CraftStudio utilise Lua pour programmer les éléments dynamiques des modèles.

Le logiciel libre d'interface neuronale directe OpenVibE (en) utilise Lua comme langage de script, en particulier pour la gestion de stimuli pour les expériences de neuroscience.

Le robot IRC irccd utilise Lua pour la création de plugins.

Lua est le langage de scripting principalement utilisé pour le système d'exploitation embarqué OpenWrt fonctionnant sur de nombreux routeurs. L'interface graphique d'administration LuCI est entièrement écrite en Lua.

Lua est le langage natif de Domoticz, logiciel de domotique open source. Il permet le scripting avec des fonctionnalités avancées : Domoticz déclenche automatiquement ces scripts sur les changements d’états, en fonction du temps, etc.

Lua est également le langage natif de NSBase, logiciel de gestion de bases données. Le scripting permet de dynamiser les formulaires, rapports. Lua ainsi intégré permet de créer de véritables applications de gestion de bases de données.

Le logiciel de simulation de vol spatial Orbiter et ses add-ons (UCGO, UMmu) utilisent Lua pour permettre la création aisée d'écrans de contr?le (MFD - Multi Function Display), de missions ou de vaisseaux. La création de vaisseaux, en particulier, à la différence de modules DLL, ne nécessite pas la compilation d'un fichier C++.

BeamNG.drive utilise Lua pour compléter ses équations physiques.

Prosody : serveur XMPP léger écrit entièrement en lua.

L'environnement de bureau Awesome (linux) utilise aussi Lua dans ses fichiers de configuration depuis sa version 3.

FreeBSD intègre un interpréteur lua dans son chargeur depuis la version 11.3.

La solution qui associe le montage, l’étalonnage, les effets visuels, les animations graphiques et la post-production audio Davinci Resolve utilise Lua, Py2 et Py3.

Le logiciel de notation musicale professionnel Finale propose un plugin Lua.

Annexes

Bibliographie

• (en) ? Lua 5.2 Reference Manual ?, sur lua.org, Lua.org et université pontificale catholique de Rio de Janeiro (consulté le 14 mai 2014)
• (en) Roberto Ierusalimschy, Programming in Lua, Rio de Janeiro, Lua.org et université pontificale catholique de Rio de Janeiro, janvier 2013, 3^e éd. (1^re éd. 2003), 347 p. (ISBN 978-85-903798-5-0 et 85-903798-5-X)
• (en) Roberto Ierusalimschy, Waldemar Celes et Luiz Henrique de Figueiredo, Lua Programming Gems, Rio de Janeiro, Brésil, Lua.org et université pontificale catholique de Rio de Janeiro, 2008, 346 p. (ISBN 978-85-903798-4-3)
• Cyril Doillon (dir.), Sylvain Fabre, Philippe Lhoste et Patrick Rapin, Le guide de Lua et ses applications : manuel d'apprentissage, Paris, D-BookeR édition, 2012, 188 p. (ISBN 978-2-8227-0005-4, lire en ligne)
• Cyril Doillon (dir.), Sylvain Fabre, Philippe Lhoste et Patrick Rapin, Le guide de Lua et ses applications : manuel de référence, Paris, D-BookeR édition, 2012, 336 p. (ISBN 978-2-8227-0015-3, lire en ligne)

Articles connexes

• Plua
• LuaTeX
• GLua

Liens externes

• (en + pt) Site officiel
• Notice dans un dictionnaire ou une encyclopédie généraliste :

  • Den Store Danske Encyklop?di
• Notices d'autorité :

  • BnF (données)
  • LCCN
  • GND
  • Isra?l
• (en) Lua Development Tools
• (en) Lua embarqué
• (fr) Introduction à la programmation avec Lua