Voir la source de Lua

{{Voir homonymes|Lua (homonymie)}}
{{Infobox Langage de programmation
| couleur boîte = 010080
| nom = {{blanc|Lua}}
| logo = Lua-Logo.svg
| paradigme = Multi-paradigme : [[Programmation procédurale|procédural]], [[Programmation orientée prototype|orienté objet à prototype]] et [[Programmation fonctionnelle|fonctionnel]]
| date de première version = [[1993 en informatique|1993]]
| auteur = Luiz Henrique de Figueiredo, Roberto Ierusalimschy et Waldemar Celes
| développeur = 
| typage = [[Typage dynamique|dynamique]], [[Typage#Typage fort et typage faible|faible]]
| normes = 
| implémentations = [http://www.lua.org Lua], [http://luajit.org LuaJIT], [http://code.google.com/p/llvm-lua LLVM-Lua], [http://code.google.com/p/luaclr LuaCLR], [http://nua.codeplex.com Nua], [http://code.google.com/p/lua-alchemy Lua Alchemy], [http://microlua.xooit.fr MicroLua],
[http://code.google.com/p/mochalua Mochalua], [http://code.google.com/p/jillcode Jill], [http://luaj.org/luaj/README.html luaj],
[https://www.luart.org LuaRT]
| influencé par = [[BASIC]], [[C (langage)|C]], [[C++]]
| a influencé = [[Micro Lua DS]]
| dernière version = 
| date de dernière version = 
| système d'exploitation = [[Multiplate-forme]]
| licence = [[Licence MIT]]
| site web = [http://www.lua.org/ lua.org]
}}

'''Lua''' est un [[langage de script]] [[Logiciel libre|libre]], [[Réflexion (informatique)|réflexif]] et [[Programmation impérative|impératif]].

Créé en [[1993 en informatique|1993]], il est conçu de manière à pouvoir être embarqué au sein d'autres applications afin d'étendre celles-ci. Lua (du {{lang-pt|[[:wikt:lua#pt|Lua]]}} {{API|[ˈlu.ɐ]}}, au [[Brésil]] : {{API|[ˈlu.a]}}, signifiant « [[Lune]] »<ref>{{lien web|langue=en| url=https://www.lua.org/about.html| titre=About| site=lua.org}}</ref>) a été développé par [[Luiz Henrique de Figueiredo]], {{Lien|Roberto Ierusalimschy|lang=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 [[C (langage)|langage C]] [[ANSI]] strict, et de ce fait est compilable sur une grande variété de systèmes. Il est également très compact, la version 5.0.2 n'occupant que {{unité|95|ko}} à {{unité|185|ko}} selon le compilateur utilisé et le système cible. Il est souvent utilisé dans des [[Système embarqué|systèmes embarqués]] tels qu'[[OpenWrt]]<ref>{{Ouvrage|titre=Luci|sous-titre=LuCI : OpenWrt Configuration Interface|éditeur=openwrt|date=2017-10-12|isbn=|lire en ligne=https://github.com/openwrt/luci|consulté le=2017-10-12}}.</ref> où cette compacité est très appréciée. Il profite de la compatibilité que possède le langage C avec un grand nombre de langages pour s'intégrer facilement dans la plupart des projets.

Il est particulièrement apprécié pour l'embarqué, le développement [[réseau]] et les [[Jeu vidéo|jeux vidéo]].

Le Lua est utilisé dans des jeux vidéo comme : ''[[Transformice]]'', ''[[World of Warcraft]]'', ''[[Roblox]]'', ''[[Garry's Mod]]'', ''[[Onset]]'', ''computercraft mod'' ([[Mod (jeu vidéo)|mod]] de ''[[Minecraft]]''), ''[[Multi Theft Auto]]'' ([[Mod (jeu vidéo)|mod]] multijoueur de ''[[Grand Theft Auto: San Andreas]]''), ''[[FiveM]]'' ([[Mod (jeu vidéo)|mod]] multijoueur de ''[[Grand Theft Auto V]]''), ainsi que les moteurs de jeu vidéo tels que le [[Source (moteur de jeu)|SourceEngine]], [[CryENGINE]], [[LÖVE]], ou encore les [[Fantasy console]]s, tel que [[Pico-8]].

Il est également utilisé au niveau réseau comme [[Hook (informatique)|hook]] sur [[Apache HTTP Server|Apache]], [[Lighttpd]] (par défaut), [[Nginx]] (via [[OpenResty]]), dans les routeurs [[Cisco]], dans l'[[analyseur de paquets]] [[Wireshark]], l'[[antispam]] [[Rspamd]], l'[[autocommutateur téléphonique privé]] [[Asterisk (logiciel)|Asterisk]] (optionnel), pour les scripts de [[MediaWiki]].

== Généralités ==

=== Commentaires ===
En Lua, les [[Commentaire (informatique)|commentaires]] débutent par <code>--</code> et finissent à la fin de la ligne, comme en [[Ada (langage)|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 <syntaxhighlight lang="lua">--[[...]] </syntaxhighlight>

=== Variables ===

Les variables peuvent contenir <code>nil</code> (la valeur nulle, vide), un booléen, une chaîne de caractères, un nombre (pas de différence entre entier et flottants), une table ou une fonction. Il existe aussi d'autres types comme <code>userdata</code> ou <code>thread</code> moins souvent rencontrés.
Le type <code>userdata</code> 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 [[Langage de haut niveau|haut niveau]] fournis par le langage.

En interne on peut aussi rencontrer les <code>proto</code>, une sorte de prototype de fonction, le [[bytecode]] de cette fonction étant chargé mais ce dernier n'a pas été exécuté; On rencontrera les protos quand un fichier est chargé (compilé) mais pas exécuté ou bien avec les [[Fermeture (informatique)|closures]].

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 <code>local</code>.

Les chaînes de caractères sont délimitées par des guillemets simples (') ou doubles ("), voire la marque de chaîne littérale <syntaxhighlight lang="lua"> [[...]] </syntaxhighlight> (multiligne, pas de caractère spécial).
L'opérateur de concaténation de chaînes se représente par deux points (<code>..</code>).

=== 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 <code>nil</code> à une fonction (eg. <code>print = nil</code>), 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.


Ces dernières sont utilisées de deux manières différentes :

* Une liste (avec un index commençant à 1 et non à 0)
* Une [[Table de hachage|hashtable]] (faisant office de struct), pouvant prendre en clé et en valeur tout type de variable non <code>nil</code>.


Il est tout à fait possible (mais fortement déconseillé pour des questions de qualité de code) d'avoir une table qui mêle liste et hashtable.

La convention veut qu'on parcoure une liste avec l'itérateur <code>ipairs</code> et la hashtable avec l'itérateur <code>pairs</code> .


Dans une table, il est impossible d'assigner une variable à nil ou l’indexer à la clé <code>nil</code>.

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 [[surcharge 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 ===
<syntaxhighlight lang="lua">
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
</syntaxhighlight>

=== Boucles ===
<syntaxhighlight lang="lua">
repeat
 -- code
until condition
</syntaxhighlight>
et
<syntaxhighlight lang="lua">
while condition do
 -- code
end
</syntaxhighlight>
ainsi que
<syntaxhighlight lang="lua">
for var = start, valend, step do
 -- code
end
</syntaxhighlight>
ou
<syntaxhighlight lang="lua">
for var_1, ..., var_n in explist do
 -- code
end
</syntaxhighlight>

== Déclaration de fonctions ==
<syntaxhighlight lang="lua">
function mafonction(arg1, arg2, ...)
 -- code
 return résultat1, résultat2
end
</syntaxhighlight> ou
<syntaxhighlight lang="lua">
mafonction = function (arg1, arg2, ...)
 -- code
 return résultat1, résultat2
end
</syntaxhighlight>

=== Appels de fonction ===
<syntaxhighlight lang="lua">
res1, res2 = mafonction(var)
</syntaxhighlight>

=== Blocs inconditionnels ===
Les blocs inconditionnels servent par exemple à déclarer des variables locales à ce bloc :
<syntaxhighlight lang="lua">
do
 local mavariable = "chaîne" -- déclaration de variable, optionnel
 -- code utilisant mavariable
end
</syntaxhighlight>

=== Déclaration de table ===
Table à indices numériques consécutifs (En Lua, le premier indice d'une table est 1)
<syntaxhighlight lang="lua">a = { 5, "foo", [[C:\Lua\Lua.exe]], 'bar', 42 } </syntaxhighlight>
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)
<syntaxhighlight lang="lua">a = { d = 5, [12] = "foo", ['chaîne avec espace'] = true }  </syntaxhighlight>
Quand on assigne une variable a une autre, si la valeur de celle-ci n'est pas un nombre, une chaine de caractères ou un booléen alors la référence de celle-ci est copiée. Donc, dans le cas des tables, si une variable a possède une table et qu'on assigne à la variable b la variable a alors toutes modifications subies par a seront directement visibles sur b
<syntaxhighlight lang="lua">
local a = {1,"b",3}
local b = a
a.foo = "bar"
print(b.foo) -- bar
-- b et a on les mêmes références
</syntaxhighlight>
Table stockant des variables complexes : autres tables, fonctions, références croisées...
Lorsque les valeurs en tant qu'indice ne sont pas des nombres, des chaines de caractères ou des booléens, alors l'indice sera la référence de la variable en question.
<syntaxhighlight lang="lua"> fonction = function (a, b) return (a + b) / a * b end
t =
{
	b =
	{
		-- Fonction comme clé
		-- La référence de la fonction agira 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é
	-- La table étant anonyme, aucune référence a cette table est stockée et donc la valeur stockée inaccessible
	[ { 'a', 'b' } ] = { "aa", "bb" },
}
-- Référence dans la table
t.reference = t.a
t.self = t -- Référence a soi même
t.self.réference = t.a
print(t[ { t.a, t.b } ]) -- nil car aucune valeur n'a pour clé la référence de cette nouvelle table, l'ancienne table a une référence différente
</syntaxhighlight>

== Les fonctions ==

=== Les fonctions mathématiques ===
La fonction math.pi permet de retourner la valeur de pi.<syntaxhighlight lang="lua">
print(math.pi) --> Affiche dans la console la valeur de pi (3.1415926535898)
</syntaxhighlight>La fonction math.min(liste) retourne le plus petit nombre contenu dans une liste<syntaxhighlight lang="lua">
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.
</syntaxhighlight>La fonction math.max(liste) retourne le plus grand nombre contenu dans une liste<syntaxhighlight lang="lua">
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.
</syntaxhighlight>La fonction math.floor(x) permet de retourner le plus grand entier inférieur ou égal à x.<syntaxhighlight lang="lua">
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
</syntaxhighlight>La fonction math.abs(x) permet de retourner la valeur absolue de x.<syntaxhighlight lang="lua">
print(math.abs(-100)) --> Retourne dans la console le nombre 100.
</syntaxhighlight>La fonction math.pow(x, y) permet de retourner x à la puissance de y. On peut aussi utiliser l'expression x^y<syntaxhighlight lang="lua">
print(math.pow(6,8)) --> Retourne dans la console le nombre 1679616.
-- On peut également utiliser:
print(6^8)
</syntaxhighlight>La fonction math.random(x, y) retourne un nombre aléatoire entre la valeur x et la valeur y.<syntaxhighlight lang="lua">
local x = 1
local y = 10

print(math.random(x, y)) --> Retourne dans la console un nombre entier aléatoire entre 1 et 10.
</syntaxhighlight>La fonction math.sqrt(x) retourne la racine carrée de x.<syntaxhighlight lang="lua">
local x = 6
print(math.sqrt(x)) --> Retourne la racine carrée de x(6) donc 2.4494897427832.
</syntaxhighlight>

=== Les fonctions os ===
La fonction os.time() retourne le nombre de secondes entre le {{date-|1 Janvier 1970}} à 00:00 et la seconde à laquelle vous appelez la fonction.<syntaxhighlight lang="lua">
print(os.time())
</syntaxhighlight>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"<syntaxhighlight lang="lua">
print(os.date()) --> Retourne Thu Jul 1 14:52:59 2021
</syntaxhighlight>La fonction os.clock() retourne le temps écoulé en seconde depuis que Lua a été lancé.<syntaxhighlight lang="lua">
print(os.clock()) --> Retourne dans la console 853312.913685
</syntaxhighlight>

=== La fonction type ===
La fonction type(x) permet de donner le type de x.<syntaxhighlight lang="lua">
local a = "Bonjour"
local b = 5
local c = true
local d

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

=== Les fonctions table ===
En lua, il existe 9 fonctions table. 

La fonction '''''table.insert(x, y, z)''''' permet d'insérer une valeur y dans un tableau x. On peut aussi lui donner une position à laquelle s'ajouter en rajoutant un argument z. Si aucun argument z n'est donné, la valeur s'affichera en dernière position de la table.<syntaxhighlight lang="lua">
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.
</syntaxhighlight>La fonction '''''table.remove(x, y)''''' permet de retirer du tableau x une valeur en indiquant la position de la valeur y.<syntaxhighlight lang="lua">
local tableau = {"je", "suis", "un", "faux", "utilisateur"}

table.remove(tableau, 4) --> Retire la valeur "faux" du tableau qui était en 4ème position. Malheureusement, on ne peut pas retirer de valeur en indiquant le nom de la valeur, si vous voulez retirer une valeur sans connaître le numéro de position, merci de suivre le paragraphe si dessous avec les boucles pairs().
</syntaxhighlight>La fonction '''''table.sort(x)''''' permet de trier et modifier la position des éléments du tableau x.<syntaxhighlight lang="lua">
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}
</syntaxhighlight>La fonction '''''table.concat(x, y)''''' permet de regrouper l'ensemble des valeurs d'un tableau et les transforme en chaines de caractères. Le y est un argument facultatif qui peuvent servir de séparateur entre chaque groupement de valeurs.<syntaxhighlight lang="lua">
local tableau = {"un", "renard", "caché", "dans", 1, "arbre"}
local concatTableau = table.concat(tableau)

print(concatTableau) --> Retourne dans la console la valeur unrenardcachédans1arbre
</syntaxhighlight>On peut aussi ajouter un séparateur lors du trie (y).<syntaxhighlight lang="lua">
local tableau = {"un", "renard", "caché", "dans", 1, "arbre"}
local concatTableau = table.concat(tableau, " | ")

print(concatTableau) --> Retourne dans la console: un | renard | caché | dans | 1 | arbre. L'argument y était " | " donc y a été ajouté entre chaque valeurs transformées.
</syntaxhighlight>La fonction '''''table.foreach(x, z)''''' ne fonctionne plus depuis la version 5.1 de lua et doit être remplacée par les boucles pairs(), voir ci-dessous.<syntaxhighlight lang="lua">
-- Maintenant obsolète.
</syntaxhighlight>La fonction '''''table.foreachi(x, y)''''' ne fonctionne plus depuis la version 5.1 de lua et doit être remplacée par les boucles ipairs().<syntaxhighlight lang="lua">
-- Maintenant obsolète.
</syntaxhighlight>La fonction '''''table.getn(x)''''' permet d'afficher la taille d'un tableau x.<syntaxhighlight lang="lua">
local tableau = {"un", "renard", "gentil"}
local longueur = table.getn(tableau)

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

=== Les fonctions strings ===
Les fonctions strings permettent de traiter les strings, il en existe 15.

Le '''''string.find(x, y)''''' permet de rechercher des caractères y dans le string x. Si ça retourne nil, rien a été trouvé, en revanche, si quelque chose est trouvé, ça va indiquer à partir de quel emplacement les caractères recherchaient sont trouvés.<syntaxhighlight lang="lua">
local variable = "Bonjour, je m'appel Lua."
local find = string.find(variable, "our")

if find then -- Si find n'est pas égal à nil est donc il a trouvé quelque chose alors
    print(find) -- Retourne le numéro de commencement des caractères recherchaient. En l'occurence, 5.
end
</syntaxhighlight>On peut aussi rajouter un argument z qui permet de commencer à chercher les caractères y à partir d'un certain caractère.<syntaxhighlight lang="lua">
local MA_VARIABLE = "Je suis quelqu'un qui suis une autre personne."
local resultat = string.find(MA_VARIABLE, "is", 17)

if resultat then -- S'il a trouvé dans le string à partir du caractère 17 un mot contenant is alors:
    print(resultat) -- Retourne dans la console l'endroit où se situe le début des caractères souhaitaient. En l'occurence, 25. 
end
</syntaxhighlight>Le '''''string.byte(x, y, z)''''' permet de retourner le code numérique des caractères (Code ASCII) de la string x.<syntaxhighlight lang="lua">
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
</syntaxhighlight>Il est aussi possible d'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).<syntaxhighlight lang="lua">
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.
</syntaxhighlight>Le '''''string.char(x)''''' permet de convertir le code numérique x qui est en code ASCII en caractères normaux.<syntaxhighlight lang="lua">
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)
</syntaxhighlight>Le '''''string.dump(x)''''' permet de convertir la fonction x en représentation binaire pour pouvoir ensuite être appelé par la fonction loadString(y).<syntaxhighlight lang="lua">
function demonstration()
    print("Lancement de la fonction")
end

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

--> Retourne dans la console "Lancement de la fonction."
</syntaxhighlight>Le '''''string.format()''''' permet de retourner une chaine de caractères formatée.<syntaxhighlight lang="lua">
print(string.format("Je suis %s, j'adore les %s, et j'aime le chiffre %i", "gentil", "bananes", 15))
--> Je suis gentil, j'adore les bananes, et j'aime le chiffre 15

--> %s permet de rajouter des strings
--> %i permet de rajouter des nombres
</syntaxhighlight>Le '''''string.gmatch(x, y)''''' permet de retourner une sous-chaîne de la chaîne principale x.<syntaxhighlight lang="lua">
for i in string.gmatch("Je suis quelqu'un de gentil", "%a+") do
	print(i)
end

Je
suis
quelqu
un
de
gentil
</syntaxhighlight>Le '''''string.gsub(x, y, z)''''' permet de remplacer les mots y d'une string x par un autre mot z.<syntaxhighlight lang="lua">
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
</syntaxhighlight>Le '''''string.upper(x)''''' permet de retourner le texte d'une string x en modifiant les minuscules en MAJUSCULES (sauf caractères spéciaux).<syntaxhighlight lang="lua">
local MA_STRING = "Je suis un éléphant Rose"
print(string.upper(MA_STRING))

-->
JE SUIS UN éLéPHANT ROSE
</syntaxhighlight>Le '''''string.lower(x)''''' permet de retourner le texte d'une string x en modifiant les MAJUSCULES par des minuscules.<syntaxhighlight lang="lua">
local MA_STRING = "JE SUIS QUELQU'UN"
print(string.lower(MA_STRING))

-->
je suis quelqu'un
</syntaxhighlight>Le '''''string.reverse(x)''''' permet de retourner le texte d'une string x en inversant la chaîne de caractères.<syntaxhighlight lang="lua">
local MA_STRING = "je suis un scripter"
print(string.reverse(MA_STRING))

-->
retpircs nu sius ej
</syntaxhighlight>Le '''''string.sub(x, y, z)''''' permet de retourner une sous-chaîne de la string x en gardant uniquement le caractère souhaitait y. S'il y'a un argument z, ça va récupérer la sous-chaîne du caractère y au caractère z. Si l'argument y est négatif, ça va commencer à l'envers et prendre la fin de phrase.<syntaxhighlight lang="lua">
local MA_STRING = "je suis un scripter"
print(string.sub(MA_STRING, 1, 7))

-->
je suis

print(string.sub(MA_STRING, -2))

--> 
e
</syntaxhighlight>Le '''''string.rep(x, y)''''' permet de multiplier le contenu de la string x avec le nombre de y.<syntaxhighlight lang="lua">
local MA_STRING = "je suis "
print(string.rep(MA_STRING, 5))

-->
je suis je suis je suis je suis je suis 
</syntaxhighlight>Le '''''string.match(x, y, z)'''''  permet de retourner une sous-chaîne de caractères de la string x en prenant ce qui est souhaitait en y commençant avec le caractère z. Z étant facultatif.<syntaxhighlight lang="lua">
local MA_STRING = "Je suis un scripter"
print(string.match(MA_STRING, "s..."))

-->
suis

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

-->
scri
</syntaxhighlight>

=== La fonction pairs() ===
La fonction pairs(x) permet de chercher différents éléments d'un tableau. Elle sert actuellement à remplacer la fonction table.foreach qui est éronnée depuis la version de lua 5.1. Son utilisation est simple, elle vient prendre le premier argument après le mot for pour faire en sorte que ce soit l'index donc qu'il porte le numéro de position dans le tableau. Et après, le deuxième argument qu'on appel souvent v pour value qui indique la valeur. Ce qui donne for i, v in pairs(x) do. Le i est le numéro de position de la valeur dans le tableau et le v est la valeur.

Pour trouver une valeur dans le tableau, on vas donc insérer un argument qui sera le nom du tableau x. <syntaxhighlight lang="lua">
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
</syntaxhighlight>Pour pouvoir retirer une valeur d'un tableau, on utilise aussi cette fonction, en les traitant jusqu'à récupérer le bon numéro:<syntaxhighlight lang="lua">
local tableau = {"un", "deux", "trois", "quatre", "cinq"}

local compteur = 0 -- Mettre la valeur à 0 pour pouvoir ensuite ajouter une valeur à chaque traitement.
for index, value in pairs(tableau) do
    compteur += 1 -- Ajoute un au compteur
    if value == "trois" then
        table.remove(tableau, compteur) -- Retire du tableau la valeur trois.
        break -- Arrêt de la boucle.
    end
end
</syntaxhighlight>

=== La fonction pcall() ===
La fonction pcall() est utilisée pour isoler les erreurs contenus dans une fonction. Cela permet d'empêcher l'arrêt du script et d'afficher s'il y'a une erreur ou non avec possibilité de voir de quelle erreur il s'agit.<syntaxhighlight lang="lua">
 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
</syntaxhighlight>La fonction pcall() peut aussi être mise en fonction avec deux variables précédentes<syntaxhighlight lang="lua">
local success, error = pcall(function()
	print(table.find("s")) --> est une erreur.
	print("Ca marche")
end)

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

if not success then -- S'il y'a pas de succès et donc a une erreur, alors:
    print(error)
end

--> Dans la console:

Je suis quelqu'un de gentil
Script:2: invalid argument #1 to 'find' (table expected, got string)
</syntaxhighlight>

== Hello World ==
<syntaxhighlight lang="lua">
print('Hello World!')
</syntaxhighlight>

== Usages ==
{{Section à sourcer|date=octobre 2016}}

=== Consoles ===
Lua a été embarqué dans la [[PlayStation Portable]] de [[Sony]], grâce 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 {{date-|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 [http://www.chip-pc.fr/pocket-chip/ Pocket Chip] (projet [https://www.kickstarter.com/projects/1598272670/chip-the-worlds-first-9-computer/description Kickstater]). En effet cette dernière embarque le programme de console virtuel [http://www.lexaloffle.com/pico-8.php Pico-8] qui permet de jouer et de créer des jeux en Lua.

=== Extensions de jeux vidéo ===
Parmi les [[Jeu vidéo|jeux vidéo]] de [[Jeu sandbox|bac à sable]] qui l'utilisent figurent ''[[Garry's Mod]]'', ''[[Roblox]]'', [[:en:Core_(video_game)|''Core'']], {{lien|lang=en|Stormworks:_Build_and_Rescue|texte=Stormworks}} et ''[[Minecraft]]''. Pour ce dernier, ''{{Langue|en|ComputerCraft}}''<ref>[http://computercraft.info Site l'extension ''{{Langue|en|ComputerCraft}}''].</ref>, une extension 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 tâches 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)<ref>[https://content.minetest.net/packages/Jeija/mesecons/ Mode de Minetest ajoutant des circuits électroniques numériques et analogique (tel que des portes logiques, des µcontrôleurs ou des FPGA) et permettant l'automatisation de certaines actions et événements.]</ref> 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 (jeu vidéo)|Far Cry]]'' (et le moteur [[CryEngine]] en général) de [[Crytek Studios]], le logiciel multijoueurs de [[Grand Theft Auto: San Andreas|GTA:SA]] ''[[Multi Theft Auto]]'', ''[[SimCity 4]]'' et ''[[Natural Selection 2]]'' de [[Unknown Worlds Entertainment]] (qui a entre autres développé [[Decoda]], un [[Environnement de développement intégré|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: Rebirth#Afterbirth †|The Binding of Isaac: Afterbirth+]]'' est un [[Contenu téléchargeable|DLC]] pour le jeu ''[[The Binding of Isaac: Rebirth]]'' qui permet le support de mods écrits en Lua<ref>{{Lien web|titre=TYRONE! NOT AGAIN!|url=http://bindingofisaac.com/post/153791362179/tyrone-not-again|site=†|consulté le=2017-01-06}}.</ref>.

=== Autres logiciels ===
Lua est également utilisé pour l'extension des capacités du lecteur multimédia [[VLC media player|VLC]], dans les [[Gestionnaire de fenêtre|gestionnaires de fenêtres]] [[EFL Edje]] d'[[Enlightenment (logiciel)|Enlightenment]] ainsi que [[Awesome (logiciel)|Awesome]] (comme langage de configuration et de script).

Le PABX [[Asterisk (logiciel)|Asterisk]] propose Lua comme alternative pour étendre son plan de numérotation.

[[MediaWiki]] et les sites [[Wikimedia]] utilisent Lua comme langage de script pour les modèles (appelés [[Aide:Module|modules]])<ref>Wikipedia Signpost, [[:en:Wikipedia:Wikipedia Signpost/2012-01-30/Technology report|Lua chosen as new template scripting language]], 30 janvier 2012 ([[mw:Lua scripting|Page de projet]]).</ref>.

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

Le logiciel libre d'[[interface neuronale directe]] {{Lien|OpenVibE}} utilise Lua comme langage de script, en particulier pour la gestion de stimuli pour les expériences de neuroscience.

Le robot IRC irccd<ref>{{en}} [http://projects.malikania.fr/irccd « {{Langue|en|IRC Client Daemon}} »].</ref> utilise Lua pour la création de plugins.

L'antispam [[Rspamd]] utilise également Lua pour son [[interface de programmation]]<ref>{{lien web|langue=en| url=https://rspamd.com/features.html| titre=Rspamd Features — Unique features|site=rspamd.com}}.</ref>.

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]] ''{{Langue|en|open source}}''. Il permet le ''{{Langue|en|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 [[sourceforge:projects/nsbase/|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 (simulateur)|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 [[Dynamic Link Library|DLL]], ne nécessite pas la compilation d'un fichier [[C++]].

[[BeamNG.drive]]<ref>{{Lien web|titre=BeamNG.drive|url=http://www.beamng.com/|consulté le=6 août 2016}}.</ref> utilise Lua pour compléter ses équations physiques.

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

L'environnement de bureau [[Awesome (logiciel)|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<ref>{{Lien web |titre=The FreeBSD Project {{!}} FreeBSD 11.3-RELEASE Release Notes |url=https://www.freebsd.org/releases/11.3R/relnotes/ |site=www.freebsd.org |consulté le=2021-04-22}}</ref>.

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

== Notes et références ==
{{Références}}

== Annexes ==
{{Autres projets
|wikt=Lua
|v=Initiation au Lua avec Scribunto
|commons=Category:Lua (programming language)
|meta=Lua
}}

=== Bibliographie ===
* {{Lien web|langue= en |url= http://www.lua.org/manual/5.2/|titre=Lua 5.2 Reference Manual  |site= http://www.lua.org|éditeur=Lua.org et [[université pontificale catholique de Rio de Janeiro]]  |consulté le=14 mai 2014}}
* {{Ouvrage |
langue                 = en |
prénom1                = Roberto |
nom1                   = Ierusalimschy |
titre                  = Programming in Lua |
lieu                   = Rio de Janeiro |
éditeur                = Lua.org et [[université pontificale catholique de Rio de Janeiro]] |
année                  = 2013 |
mois                   = janvier |
numéro d'édition       = 3 |
année première édition = 2003 |
pages totales          = 347 |
isbn                   = 978-85-903798-5-0 |
isbn2                  = 85-903798-5-X 
}}
* {{Ouvrage |
langue        = en |
prénom1       = Roberto |
nom1          = Ierusalimschy |
prénom2       = Waldemar |
nom2          = Celes |
prénom3       = Luiz Henrique de |
nom3          = Figueiredo |
titre         = Lua Programming Gems |
lieu          = Rio de Janeiro, Brésil |
éditeur       = Lua.org et [[université pontificale catholique de Rio de Janeiro]] |
année         = 2008 |
pages totales = 346 |
isbn          = 978-85-903798-4-3
}}
* {{Ouvrage |
langue        = fr |
nom1          = Cyril Doillon |
directeur1    = Sylvain Fabre |
nom2          = Sylvain Fabre |
nom3          = Philippe Lhoste |
nom4          = Patrick Rapin |
titre         = Le guide de Lua et ses applications |
sous-titre    = manuel d'apprentissage |
lieu          = Paris |
éditeur       = D-BookeR édition |
année         = 2012 |
pages totales = 188 |
isbn          = 978-2-8227-0005-4 |
lire en ligne = http://www.d-booker.fr/programmation-et-langage/1-livre-lua.html (payant)
}}
* {{Ouvrage |
langue        = fr |
nom1          = Cyril Doillon |
directeur1    = Sylvain Fabre |
nom2          = Sylvain Fabre |
nom3          = Philippe Lhoste |
nom4          = Patrick Rapin |
titre         = Le guide de Lua et ses applications |
sous-titre    = manuel de référence |
lieu          = Paris |
éditeur       = D-BookeR édition |
année         = 2012 |
pages totales = 336 |
isbn          = 978-2-8227-0015-3 |
lire en ligne = http://www.d-booker.fr/programmation-et-langage/1-livre-lua.html (payant)
}}

=== Articles connexes ===
* [[Plua]]
* [[LuaTeX]]

=== Liens externes ===
* {{Site officiel|en|http://www.lua.org/}}
* {{en}} [https://eclipse.org/ldt/ Lua Development Tools]
* {{en}} [http://www.eluaproject.net/ Lua embarqué]
* {{fr}} [http://www.luteus.biz/Download/LoriotPro_Doc/LUA/LUA_Training_FR/Introduction_Programmation.html Introduction à la programmation avec Lua]

{{Palette|Langages de programmation}}
{{Portail|programmation informatique|jeu vidéo}}

[[Catégorie:Lua| ]]
[[Catégorie:Langage de script]]
[[Catégorie:Langage impératif]]
[[Catégorie:Invention brésilienne]]
[[Catégorie:Développement de jeux vidéo]]