Lua (langage de programmation)

L’article porte sur le langage de programmation Lua lui-même. Pour son utilisation dans Wikipedia, voir Wikipedia:Lua .

Lua ( / ˈ l uː ə / LOO -ə ; du portugais : lua [ˈlu.(w)ɐ] signifiant lune ) est un langage de programmation léger , de haut niveau et Multi-paradigme conçu principalement pour une utilisation intégrée dans les applications. ^[3] Lua est Multiplateforme , puisque l’ interpréteur de bytecode compilé est écrit en ANSI C ,^[4] et Lua a une API C relativement simplepour l’intégrer dans les applications. ^[5]

Lua

Principales implémentations

Paradigme	Multi-paradigme : scripting , impératif ( procédural , basé sur des prototypes , orienté objet ), fonctionnel , méta , réflexif
Conçu par	Roberto Ierusalimschy Waldemar Celes Luiz Henrique de Figueiredo
Première apparition	1993 ; il y a 29 ans ( 1993 )
Version stable	5.4.4 ^[1] / 26 janvier 2022 ; il y a 3 mois ( 26 janvier 2022 )
Discipline de frappe	Dynamique , fort , canard
Langage d’implémentation	ANSI C
SE	Multiplateforme
Licence	Licence MIT
Extensions de nom de fichier	.lua
Site Internet	www .lua .org
Lua , LuaJIT , LuaVela , MoonSharp , Luvit , LuaRT , Luau
Dialectes
Metalua , inactif , coque GSL
Influencé par
C++ , CLU , Modula , Schéma , SNOBOL
Influencé
GameMonkey , Io , JavaScript , Julia , MiniD, Red , Ring , ^[2] Ruby , Squirrel , MoonScript, C–

Lua a été conçu à l’origine en 1993 comme un langage pour étendre les applications logicielles afin de répondre à la demande croissante de personnalisation à l’époque. Il fournissait les fonctionnalités de base de la plupart des langages de programmation procéduraux , mais les fonctionnalités plus compliquées ou spécifiques à un domaine n’étaient pas incluses; il incluait plutôt des mécanismes d’extension du langage, permettant aux programmeurs d’implémenter de telles fonctionnalités. Comme Lua était destiné à être un langage d’extension général intégrable, les concepteurs de Lua se sont concentrés sur l’amélioration de sa vitesse , de sa portabilité , de son extensibilité et de sa facilité d’utilisation dans le développement.

Histoire

Lua a été créé en 1993 par Roberto Ierusalimschy , Luiz Henrique de Figueiredo et Waldemar Celes, membres du groupe de technologie informatique graphique (Tecgraf) de l’ Université catholique pontificale de Rio de Janeiro , au Brésil .

De 1977 à 1992, le Brésil avait une politique de fortes barrières commerciales (appelée réserve de marché) pour le matériel informatique et les logiciels. Dans cette atmosphère, les clients de Tecgraf ne pouvaient pas se permettre, ni politiquement ni financièrement, d’acheter des logiciels personnalisés à l’étranger. Ces raisons ont conduit Tecgraf à mettre en œuvre les outils de base dont il avait besoin à partir de zéro. ^[6]

Les prédécesseurs de Lua étaient les langages de description/configuration de données SOL (Simple Object Language) et DEL (langage de saisie de données). ^[7] Ils avaient été développés indépendamment chez Tecgraf en 1992–1993 pour ajouter une certaine flexibilité dans deux projets différents (les deux étaient des programmes graphiques interactifs pour les applications d’ingénierie de la société Petrobras ). Il y avait un manque de structures de contrôle de flux dans SOL et DEL, et Petrobras ressentait un besoin croissant de leur ajouter une puissance de programmation complète.

Dans The Evolution of Lua , les auteurs du langage ont écrit : ^[6]

En 1993, le seul véritable concurrent était Tcl , qui avait été explicitement conçu pour être intégré dans des applications. Cependant, Tcl avait une syntaxe inconnue, n’offrait pas un bon support pour la description des données et ne fonctionnait que sur les plates-formes Unix. Nous n’avons pas considéré LISP ou Scheme en raison de leur syntaxe peu conviviale. Pythonétait encore à ses balbutiements. Dans l’atmosphère de bricolage libre qui régnait alors à Tecgraf, il était tout naturel que nous essayions de développer notre propre langage de script… Parce que de nombreux utilisateurs potentiels du langage n’étaient pas des programmeurs professionnels, le langage devait éviter les énigmes syntaxe et sémantique. L’implémentation du nouveau langage devait être hautement portable, car les clients de Tecgraf disposaient d’un ensemble très diversifié de plates-formes informatiques. Enfin, puisque nous nous attendions à ce que d’autres produits Tecgraf aient également besoin d’intégrer un langage de script, le nouveau langage devrait suivre l’exemple de SOL et être fourni sous forme de bibliothèque avec une API C.

Lua 1.0 a été conçu de telle manière que ses constructeurs d’objets, étant alors légèrement différents du style actuel léger et flexible, incorporaient la syntaxe de description de données de SOL (d’où le nom Lua : Sol signifiant “Soleil” en portugais, et Lua signifiant “Lune”). La syntaxe Lua pour les structures de contrôle était principalement empruntée à Modula ( if, while, repeat/ until), mais avait également pris l’influence de CLU (plusieurs affectations et plusieurs retours d’appels de fonction, comme alternative plus simple aux paramètres de référence ou aux pointeurs explicites ), C++ (“bonne idée d’autoriser une variable localeà déclarer uniquement là où nous en avons besoin” ^[6] ), SNOBOL et AWK ( tableaux associatifs ). Dans un article publié dans le Dr. Dobb’s Journal , les créateurs de Lua déclarent également que LISP et Scheme avec leur mécanisme de structure de données unique et omniprésent ( la liste ) ont eu une influence majeure sur leur décision de développer la table comme structure de données primaire de Lua. ^[8]

La sémantique Lua a été de plus en plus influencée par Scheme au fil du temps, ^[6] en particulier avec l’introduction de fonctions anonymes et d’une Portée lexicale complète . Plusieurs fonctionnalités ont été ajoutées dans les nouvelles versions de Lua.

Les versions de Lua antérieures à la version 5.0 étaient publiées sous une licence similaire à la licence BSD . Depuis la version 5.0, Lua est sous licence MIT . Les deux sont des Licences de logiciels libres permissives et sont presque identiques.

Caractéristiques

Wikibooks a un livre sur le thème de : Programmation Lua

Lua est communément décrit comme un langage ” multi-paradigmes “, fournissant un petit ensemble de fonctionnalités générales qui peuvent être étendues pour s’adapter à différents types de problèmes. Lua ne contient pas de support explicite pour l’ héritage , mais permet de l’implémenter avec des métatables . De même, Lua permet aux programmeurs d’implémenter des espaces de noms , des classes et d’autres fonctionnalités associées à l’aide de son implémentation de table unique ; des fonctions de premier ordre permettent l’emploi de nombreuses techniques issues de la programmation fonctionnelle ; et la Portée lexicale complète permet de cacher des informations fines pour appliquer le principe du moindre privilège.

En général, Lua s’efforce de fournir des méta-fonctionnalités simples et flexibles qui peuvent être étendues selon les besoins, plutôt que de fournir un ensemble de fonctionnalités spécifiques à un paradigme de programmation. En conséquence, le langage de base est léger — l’ interpréteur de référence complet ne fait qu’environ 247 ko compilé ^[4] — et facilement adaptable à un large éventail d’applications.

Langage à typage dynamique destiné à être utilisé comme langage d’extension ou langage de script , Lua est suffisamment compact pour s’adapter à une variété de plates-formes hôtes. Il ne prend en charge qu’un petit nombre de structures de données atomiques telles que les valeurs booléennes , les nombres ( virgule flottante double précision et entiers 64 bits par défaut) et les chaînes . Les structures de données typiques telles que les tableaux , les ensembles , les listes et les enregistrements peuvent être représentées à l’aide de la structure de données native unique de Lua, la table , qui est essentiellement un tableau associatif hétérogène .

Lua implémente un petit ensemble de fonctionnalités avancées telles que les fonctions de première classe , le ramasse -miettes , les fermetures , les appels de queue appropriés , la coercition (conversion automatique entre les valeurs de chaîne et de nombre au moment de l’exécution), les coroutines (multitâche coopérative) et le chargement de module dynamique .

Syntaxe

Le classique “Hello, World!” programme peut être écrit comme suit : ^[9]

impression ( “Hello, World!” )

ou comme :

imprimer “Hello, World!”

Un commentaire en Lua commence par un double trait d’union et va jusqu’à la fin de la ligne, similaire à Ada , Eiffel , Haskell , SQL et VHDL . Les chaînes multilignes et les commentaires sont ornés de doubles crochets.

La fonction factorielle est implémentée en tant que fonction dans cet exemple :

fonction factorielle ( n ) locale x = 1 pour i = 2 , n faire x = x * i fin retour x fin

Flux de contrôle

Lua a un type de test conditionnel : if then endavec des constructions facultatives elseet de elseif thencontrôle d’exécution.

L’instruction générique if then endnécessite les trois mots clés :

si condition alors –statement fin du corps

Le elsemot-clé peut être ajouté avec un bloc d’instructions d’accompagnement pour contrôler l’exécution lorsque la ifcondition est évaluée àfalse :

if condition then –statement body else –statement body end

L’exécution peut également être contrôlée selon plusieurs conditions à l’aide des mots- elseif thenclés :

if condition then –statement body elseif condition then –statement body else –optionnel –optionnel default instruction body end

Lua a quatre types de boucles conditionnelles : la whileboucle , la repeatboucle (similaire à une do whileboucle ), la forboucle numérique et la boucle générique for.

–condition = vrai tandis que la condition do –statements se termine répéter –instructions jusqu’à la condition for i = first , last , delta do –delta peut être négatif, permettant à la boucle for de compter vers le bas ou vers le haut –instructions –example: print(i) end

forLa boucle générique :

for key , value in pairs ( _G ) do print ( key , value ) end

itérerait sur la table _Gen utilisant la fonction itérateur standard pairs, jusqu’à ce qu’elle revienne nil.

Les boucles peuvent également être imbriquées (placées à l’intérieur d’une autre boucle).

grille locale = { { 11 , 12 , 13 }, { 21 , 22 , 23 }, { 31 , 32 , 33 } } for y , row in ipairs ( grid ) do for x , value in ipairs ( row ) do print ( x , y , value ) end end

Les fonctions

Le traitement par Lua des fonctions en tant que valeurs de première classe est illustré dans l’exemple suivant, où le comportement de la fonction d’impression est modifié :

do local oldprint = print — Stocke la fonction d’impression actuelle en tant que fonction oldprint print ( s ) — [[ Redéfinit la fonction d’impression. La fonction d’impression habituelle peut toujours être utilisée via oldprint. Le nouveau n’a qu’un seul argument.]] oldprint ( s == “foo” et “bar” ou s ) end end

Tous les appels futurs à printseront désormais acheminés via la nouvelle fonction, et en raison de la Portée lexicale de Lua , l’ancienne fonction print ne sera accessible que par la nouvelle print modifiée.

Lua prend également en charge les fermetures , comme illustré ci-dessous :

function addto ( x ) — Renvoie une nouvelle fonction qui ajoute x à l’argument return function ( y ) –[=[ Lorsque nous nous référons à la variable x, qui est en dehors de la portée actuelle et dont la durée de vie serait plus courte que celle de cette fonction anonyme , Lua crée une fermeture.]=] return x + y end end fourplus = addto ( 4 ) print ( fourplus ( 3 )) — Prints 7 –Cela peut également être réalisé en appelant la fonction de la manière suivante : print ( addto ( 4 )( 3 )) –[[ C’est parce que nous appelons la fonction renvoyée à partir de ‘addto(4)’ avec l’argument ‘ 3’ directement. Cela permet également de réduire le coût des données et d’augmenter les performances en cas d’appel itératif. ]]

Une nouvelle fermeture pour la variable xest créée à chaque fois addtoqu’elle est appelée, de sorte que chaque nouvelle fonction anonyme renvoyée accède toujours à son propre xparamètre. La fermeture est gérée par le ramasse-miettes de Lua, comme n’importe quel autre objet.

les tables

Les tables sont les structures de données les plus importantes (et, par conception, le seul type de données composite intégré ) dans Lua et sont la base de tous les types créés par l’utilisateur. Ce sont des tableaux associatifs avec ajout de clé numérique automatique et syntaxe spéciale.

Une table est une collection de paires de clés et de données, où les données sont référencées par clé ; en d’autres termes, il s’agit d’un tableau associatif hétérogène haché .

Les tables sont créées à l’aide de la {}syntaxe du constructeur.

a_table = {} — Crée une nouvelle table vide

Les tables sont toujours passées par référence (voir Appel par partage ).

Une clé (index) peut être n’importe quelle valeur sauf nilet NaN , y compris les fonctions.

a_table = { x = 10 } — Crée une nouvelle table, avec une entrée mappant “x” au nombre 10. print ( a_table [ “x” ]) — Imprime la valeur associée à la clé de chaîne, dans ce cas 10 . b_table = a_table b_table [ “x” ] = 20 — La valeur dans la table a été changée en 20. print ( b_table [ “x” ]) — Imprime 20. print ( a_table [ “x” ]) — Affiche également 20, car a_table et b_table font référence à la même table.

Une table est souvent utilisée comme structure (ou record ) en utilisant des chaînes comme clés. Parce qu’une telle utilisation est très courante, Lua propose une syntaxe spéciale pour accéder à ces champs. ^[dix]

point = { x = 10 , y = 20 } — Créer un nouveau tableau print ( point [ “x” ]) — Imprime 10 print ( point . x ) — A exactement la même signification que la ligne ci-dessus. La notation par points plus facile à lire n’est que du sucre syntaxique.

En utilisant une table pour stocker des fonctions associées, elle peut agir comme un espace de noms.

Learn more.

Drapeau de l’Ulster

Jul 14, 2022

Reine femelle (glisser)

Jul 14, 2022

Trident (programme nucléaire britannique)

Jul 14, 2022

Gangwon, Corée du Sud

Jul 14, 2022

Point = {} Pointe . new = function ( x , y ) return { x = x , y = y } — return {[“x”] = x, [“y”] = y} end Pointe . set_x = fonction ( point , x ) point . x = x — point[“x”] = x ; finir

Les tableaux se voient automatiquement attribuer une clé numérique, ce qui leur permet d’être utilisés comme type de données tableau . Le premier index automatique est 1 plutôt que 0 comme c’est le cas pour de nombreux autres langages de programmation (bien qu’un index explicite de 0 soit autorisé).

Une clé numérique 1est distincte d’une clé de chaîne “1”.

array = { “a” , “b” , “c” , “d” } — Les indices sont attribués automatiquement. print ( array [ 2 ]) — Affiche “b”. L’indexation automatique dans Lua commence à 1. print ( # array ) — Affiche 4. # est l’opérateur de longueur pour les tables et les chaînes. array [ 0 ] = “z” — Zéro est un index légal. print ( # array ) — Affiche toujours 4, car les tableaux Lua sont basés sur 1.

La longueur d’une table test définie comme n’importe quel indice entier ntel que t[n]not nilet t[n+1]is nil; de plus, si t[1]est nil, npeut être nul. Pour un tableau régulier, avec des valeurs non nulles de 1 à un donné n, sa longueur est exactement celle n, l’indice de sa dernière valeur. Si le tableau a des “trous” (c’est-à-dire des valeurs nulles entre d’autres valeurs non nulles), alors #tpeut être n’importe lequel des indices qui précèdent directement une nilvaleur (c’est-à-dire qu’il peut considérer toute valeur nulle comme la fin du tableau ). ^[11]

ExampleTable = { { 1 , 2 , 3 , 4 }, { 5 , 6 , 7 , 8 } } print ( ExampleTable [ 1 ][ 3 ]) — Affiche “3” print ( ExampleTable [ 2 ][ 4 ]) – – Gravures “8”

Une table peut être un tableau d’objets.

function Point ( x , y ) — Constructeur d’objet “Point” return { x = x , y = y } — Crée et renvoie un nouvel objet (table) end array = { Point ( 10 , 20 ), Point ( 30 , 40 ), Point ( 50 , 60 ) } — Crée un tableau de points — tableau = { { x = 10, y = 20 }, { x = 30, y = 40 }, { x = 50, y = 60 } } ; imprimer (tableau [ 2 ]. y ) — Impressions 40

L’utilisation d’une carte de hachage pour émuler un tableau est normalement plus lente que l’utilisation d’un tableau réel ; cependant, les tables Lua sont optimisées pour être utilisées comme tableaux afin d’éviter ce problème. ^[12]

Métatables

La sémantique extensible est une caractéristique clé de Lua, et le concept de métatable permet une puissante personnalisation des tables. L’exemple suivant illustre une table “infinie”. Pour tout n, fibs[n]donnera le n-ème nombre de Fibonacci en utilisant la programmation dynamique et la mémorisation .

fibs = { 1 , 1 } — Valeurs initiales pour fibs[1] et fibs[2]. setmetatable ( fibs , { __index = function ( values , n ) –[[__index est une fonction prédéfinie par Lua, elle est appelée si la clé “n” n’existe pas.]] values [ n ] = values [ n – 1 ] + valeurs [ n – 2 ] — Calcule et mémorise fibs[n]. valeurs de retour [ n ] fin })

Programmation orientée objet

Bien que Lua n’ait pas de concept intégré de classes , la programmation orientée objet peut être émulée à l’aide de fonctions et de tables. Un objet est formé en plaçant des méthodes et des champs dans une table. L’héritage (à la fois unique et multiple) peut être implémenté avec des métatables , déléguant des méthodes et des champs inexistants à un objet parent.

Il n’y a pas de concept de « classe » avec ces techniques ; à la place, des prototypes sont utilisés, similaires à Self ou JavaScript . Les nouveaux objets sont créés soit avec une méthode de fabrique (qui construit de nouveaux objets à partir de zéro) soit en clonant un objet existant.

Création d’un objet vectoriel de base :

Vecteur local = {} VectorMeta local = { __index = Vecteur } fonction Vecteur . new ( x , y , z ) – Le retour du constructeur setmetatable ({ x = x , y = y , z = z }, VectorMeta ) end fonction Vecteur . magnitude ( self ) — Une autre méthode return math.sqrt ( self . x ^ 2 + self . y ^ 2 + self . z ^ 2 ) end vec local = Vecteur . new ( 0 , 1 , 0 ) — Créer un vecteur print ( vec . magnitude ( vec )) — Appeler une méthode (sortie : 1) print ( vec . x ) — Accéder à une variable membre (sortie : 0)

Ici, setmetatableindique à Lua de rechercher un élément dans le Vectortableau s’il n’est pas présent dans le vectableau. , qui équivaut à , recherche d’abord l’ élément dans la table . La table n’a pas d’ élément, mais sa métatable délègue à la table pour l’ élément lorsqu’il n’est pas trouvé dans la table.vec.magnitudevec[“magnitude”]vecmagnitudevecmagnitudeVectormagnitudevec

Lua fournit du sucre syntaxique pour faciliter l’orientation de l’objet. Pour déclarer des fonctions membres dans une table prototype, on peut utiliser , qui équivaut à . L’appel des méthodes de classe utilise également les deux-points : est équivalent à .function table:func(args)function table.func(self, args)object:func(args)object.func(object, args)

Cela à l’esprit, voici une classe correspondante avec :du sucre syntaxique :

Vecteur local = {} Vecteur . __index = Vecteur function Vector : new ( x , y , z ) — Le constructeur — Puisque la définition de la fonction utilise deux-points, — son premier argument est “self” qui fait référence — à “Vector” return setmetatable ({ x = x , y = y , z = z }, soi ) fin function Vector : magnitude () — Autre méthode — Référencez l’objet implicite en utilisant self return math.sqrt ( self . x ^ 2 + self . y ^ 2 + self . z ^ 2 ) end local vec = Vector : new ( 0 , 1 , 0 ) — Créer un vecteur print ( vec : magnitude ()) — Appeler une méthode (sortie : 1) print ( vec . x ) — Accéder à une variable membre (sortie : 0) Héritage

Lua prend en charge l’utilisation de métatables pour donner l’héritage de classe Lua. ^[13] Dans cet exemple, nous permettons aux vecteurs d’avoir leurs valeurs multipliées par une constante dans une classe dérivée.

Vecteur local = {} Vecteur . __index = Vecteur function Vector : new ( x , y , z ) — Le constructeur — Ici, self fait référence à la méthode “new” — de la classe que nous appelons. Dans une classe dérivée, self sera — sera la classe dérivée ; dans la classe Vector, self — sera Vector return setmetatable ({ x = x , y = y , z = z }, self ) end function Vector : magnitude () — Autre méthode — Référencez l’objet implicite en utilisant self return math.sqrt ( self . x ^ 2 + self . y ^ 2 + self . z ^ 2 ) end — Exemple d’héritage de classe local VectorMult = {} VectorMult . __index = VectorMult setmetatable ( VectorMult , Vector ) — Faire de VectorMult un enfant de Vector fonction VectorMult : multiplier ( valeur ) soi . x = soi . x * valeur soi . y = soi . y * valeur de soi . z = soi . z * valeur retour auto fin local vec = VectorMult : new ( 0 , 1 , 0 ) — Créer un vecteur print ( vec : magnitude ()) — Appeler une méthode (sortie : 1) print ( vec . y ) — Accéder à une variable membre (sortie : 1) vec : multiplier ( 2 ) — Multiplier tous les composants du vecteur par 2 print ( vec . y ) — Accéder à nouveau au membre (sortie : 2)

Lua prend également en charge l’héritage multiple ; __indexpeut être une fonction ou une table. ^[14] La surcharge de l’opérateur peut également être effectuée ; Les métatables Lua peuvent contenir des éléments tels que __add, __sub, etc. ^[15]

Mise en œuvre

Les programmes Lua ne sont pas interprétés directement à partir du fichier textuel Lua, mais sont compilés en bytecode, qui est ensuite exécuté sur la machine virtuelle Lua . Le processus de compilation est généralement invisible pour l’utilisateur et est effectué pendant l’exécution , en particulier lorsqu’un compilateur JIT est utilisé, mais il peut être effectué hors ligne afin d’augmenter les performances de chargement ou de réduire l’empreinte mémoire de l’environnement hôte en omettant le compilateur. Le bytecode Lua peut également être produit et exécuté depuis Lua, en utilisant la dumpfonction de la bibliothèque de chaînes et les load/loadstring/loadfilefonctions. La version 5.3.4 de Lua est implémentée dans environ 24 000 lignes de code C. ^{[3] [4]}

Comme la plupart des processeurs, et contrairement à la plupart des machines virtuelles (qui sont basées sur la pile ), la machine virtuelle Lua est basée sur les registres et ressemble donc plus à une conception matérielle réelle. L’architecture du registre évite à la fois une copie excessive des valeurs et réduit le nombre total d’instructions par fonction. La machine virtuelle de Lua 5 est l’une des premières machines virtuelles pures basées sur des registres à avoir une large utilisation. ^[16] Parrot et Dalvik d’ Android sont deux autres machines virtuelles basées sur des registres bien connues. La machine virtuelle de PCScheme était également basée sur des registres. ^[17]

Cet exemple est la liste de bytecode de la fonction factorielle définie ci- dessus (comme indiqué par le luaccompilateur 5.1): ^[18]

fonction <factorial.lua:1,7> (9 instructions, 36 octets à 0x8063c60) 1 paramètre, 6 slots, 0 upvalues, 6 locales, 2 constantes, 0 fonctions 1 [2] CHARGER 1 -1 ; 1 2 [3] CHARGER 2 -2 ; 2 3 [3] DEPLACER 3 0 4 [3] CHARGER 4 -1 ; 1 5 [3] FORPREP 2 1 ; à 7 6 [4] MUL 1 1 5 7 [3] BOUCLE POUR 2 -2 ; à 6 8 [6] RETOUR 1 2 9 [7] RETOUR 0 1

API C

Lua est destiné à être intégré dans d’autres applications et fournit une API C à cette fin. L’API est divisée en deux parties : le noyau Lua et la bibliothèque auxiliaire Lua. ^[19] La conception de l’API Lua élimine le besoin de gestion manuelle des références dans le code C, contrairement à l’API de Python . L’API, comme le langage, est minimaliste. La fonctionnalité avancée est fournie par la bibliothèque auxiliaire, qui se compose en grande partie de macros de préprocesseur qui facilitent les opérations de table complexes.

L’API Lua C est basée sur la pile . Lua fournit des fonctions pour pousser et faire apparaître la plupart des types de données C simples (entiers, flottants, etc.) vers et depuis la pile, ainsi que des fonctions pour manipuler des tables à travers la pile. La pile Lua est quelque peu différente d’une pile traditionnelle ; la pile peut être indexée directement, par exemple. Les indices négatifs indiquent des décalages par rapport au sommet de la pile. Par exemple, −1 est le haut (valeur la plus récemment poussée), tandis que les indices positifs indiquent des décalages par rapport au bas (valeur la plus ancienne). Le regroupement des données entre les fonctions C et Lua est également effectué à l’aide de la pile. Pour appeler une fonction Lua, les arguments sont poussés sur la pile, puis lelua_callest utilisé pour appeler la fonction proprement dite. Lors de l’écriture d’une fonction C à appeler directement depuis Lua, les arguments sont lus depuis la pile.

Voici un exemple d’appel d’une fonction Lua depuis C :

#include <stdio.h> #include <lua.h> // Bibliothèque principale Lua (lua_*) #include <lauxlib.h> // Bibliothèque auxiliaire Lua (luaL_*) int principal ( vide ) { // crée un état Lua lua_State * L = luaL_newstate (); // charge et exécute une chaîne if ( luaL_dostring ( L , “function foo (x,y) return x+y end” )) { lua_close ( L ); retour -1 ; } // envoie la valeur de global “foo” (la fonction définie ci-dessus) // à la pile, suivie des entiers 5 et 3 lua_getglobal ( L , “foo” ); lua_pushinteger ( L , 5 ); lua_pushinteger ( L , 3 ); lua_call ( L , 2 , 1 ); // appelle une fonction avec deux arguments et une valeur de retour printf ( “Résultat : %d n ” , lua_tointeger ( L , -1 )); // affiche la valeur entière de l’élément en haut de la pile lua_pop ( L , 1 ); // renvoie la pile à son état d’origine lua_close ( L ); // ferme l’état Lua return 0 ; }

L’exécution de cet exemple donne :

$ cc -o exemple exemple.c -llua $ ./exemple Résultat : 8

L’API C fournit également des tables spéciales, situées à divers “pseudo-indices” dans la pile Lua. LUA_GLOBALSINDEXAvant Lua 5.2 ^[20] se trouve la table globals, issue _Gde Lua, qui est l’ espace de noms principal . Il existe également un registre situé dans LUA_REGISTRYINDEXlequel les programmes C peuvent stocker les valeurs Lua pour une récupération ultérieure.

Il est possible d’écrire des modules d’extension en utilisant l’API Lua. Les modules d’extension sont des objets partagés qui peuvent être utilisés pour étendre les fonctionnalités de l’interpréteur en fournissant des fonctionnalités natives aux scripts Lua. Du côté Lua, un tel module apparaît comme une table d’espace de noms contenant ses fonctions et ses variables. Les scripts Lua peuvent charger des modules d’extension en utilisant require, ^[19] tout comme les modules écrits en Lua lui-même. Une collection croissante de modules appelés rocks est disponible via un système de gestion de packages appelé LuaRocks , ^[21] dans l’esprit de CPAN , RubyGems et Python egg . Lua préécritdes liaisons existent pour la plupart des langages de programmation populaires, y compris d’autres langages de script. ^[22] Pour C++, il existe un certain nombre d’approches basées sur des modèles et des générateurs de liaison automatiques.

Applications

Dans le développement de jeux vidéo , Lua est largement utilisé comme langage de script par les programmeurs , principalement en raison de sa facilité d’intégration perçue, de sa rapidité d’exécution et de sa courte courbe d’apprentissage . ^[23] Les jeux notables qui utilisent Lua incluent Roblox , ^[24] Garry’s Mod , Payday 2 , Phantasy Star Online 2 , Dota 2 , Angry Birds Space , ^[25] Crysis , ^[26] et bien d’autres. Certains jeux qui ne prennent pas en charge nativement la programmation ou les scripts Lua ont cette fonctionnalité ajoutée par des mods, tels que ComputerCraftfait pour Minecraft . De plus, Lua est également utilisé dans des logiciels autres que des jeux vidéo, tels qu’Adobe Lightroom , Moho , iClone , Aerospike et certains logiciels système dans FreeBSD et NetBSD , et est utilisé comme modèle de langage de script sur MediaWiki à l’aide de l’extension Scribunto. ^[27]

En 2003, un sondage mené par GameDev.net a montré que Lua était le langage de script le plus populaire pour la programmation de jeux. ^[28] Le 12 janvier 2012, Lua a été annoncée comme lauréate du Front Line Award 2011 du magazine Game Developer dans la catégorie Outils de programmation. ^[29]

Un grand nombre d’applications non ludiques utilisent également Lua pour l’extensibilité, telles que LuaTeX , une implémentation du langage de composition de type TeX , Redis , une base de données clé-valeur , Neovim , un éditeur de texte , Nginx , un serveur Web , et Wireshark , un analyseur de paquets réseau.

Grâce à l’extension Scribunto, Lua est disponible en tant que langage de script côté serveur dans le logiciel MediaWiki qui alimente Wikipedia et d’autres wikis. ^[30] Parmi ses utilisations permettent l’intégration des données de Wikidata dans les articles, ^[31] et alimenter le système automatisé de taxobox .

Langues dérivées

Langages qui compilent en Lua

MoonScript est un langage de script dynamique , sensible aux espaces blancs, inspiré de CoffeeScript , qui est compilé dans Lua. Cela signifie qu’au lieu d’utiliser et (ou et ) pour délimiter des sections de code, il utilise des sauts de ligne et un style d’indentation . ^{[32] [33] [34]} Une utilisation notable de MoonScript est un site Web de distribution de jeux vidéo Itch.io .doend{}
Haxe prend en charge la compilation vers une cible Lua, prenant en charge Lua 5.1-5.3 ainsi que LuaJIT 2.0 et 2.1.
Fenouil, un dialecte Lisp qui cible Lua. ^[34]
Urn, un dialecte Lisp construit sur Lua. ^[35]
Amulet, un langage fonctionnel de type ML , dont le compilateur génère des fichiers Lua. ^[36]

Dialectes

LuaJIT
Luau de Roblox , langage Lua 5.1 avec une frappe progressive et des ajouts ergonomiques. ^[37]
Ravi, langage Lua 5.3 compatible JIT avec typage statique en option. JIT est guidé par les informations de type. ^[38]
Shine, un fork de LuaJIT avec de nombreuses extensions, dont un système de modules et un système de macros. ^[39]

De plus, la communauté des utilisateurs de Lua fournit des correctifs de puissance en plus de l’implémentation C de référence. ^[40]

Voir également

Comparaison des langages de programmation

Références

^ “Lua 5.4.4 maintenant disponible” . 26 janvier 2022 . Récupéré le 28 janvier 2022 .
^ Ring Team (5 décembre 2017). “Le langage de programmation Ring et d’autres langages” . ring-lang.net .
^ ^un ^b Ierusalimschy, Roberto; de Figueiredo, Luiz Henrique; Filho, Waldemar Celes (juin 1996). “Lua—Un langage d’extension extensible” . Logiciel : pratique et expérience . 26 (6): 635–652. doi : 10.1002/(SICI)1097-024X(199606)26:6<635::AID-SPE26>3.0.CO;2-P . Récupéré le 24 octobre 2015 .
^ ^un ^{bc “À propos de} ^Lua ” . Lua.org . Récupéré le 11 août 2011 .
^ Yuri Takhteyev (21 avril 2013). “Du Brésil à Wikipédia” . Affaires étrangères . Récupéré le 25 avril 2013 .
^ ^un ^bcd ^{Ierusalimschy} , ^R. ; Figueiredo, LH; En ligneCeles, W. (2007). “L’évolution de Lua” (PDF) . Proc. de l’ACM HOPL III . p. 2–1–2–26. doi : 10.1145/1238844.1238846 . ISBN 978-1-59593-766-7. S2CID 475143 .^{[ lien mort ]}
^ “L’évolution d’un langage d’extension : une histoire de Lua” . 2001 . Récupéré le 18 décembre 2008 .
^ Figueiredo, LH; Ierusalimschy, R.; Celes, W. (décembre 1996). “Lua : un langage embarqué extensible. Quelques métamécanismes remplacent une foule de fonctionnalités” . Journal du Dr Dobb . Vol. 21, non. 12. p. 26–33.
^ “Programmation en Lua : 1” .
^ “Manuel de référence Lua 5.1” . 2014 . Récupéré le 27 février 2014 .
^ “Manuel de référence Lua 5.1” . 2012 . Récupéré le 16 octobre 2012 .
^ “Code Source Lua 5.1” . 2006 . Récupéré le 24 mars 2011 .
^ Roberto Ierusalimschy. Programmation en Lua, 4e édition . p. 165.
^ “Programmation en Lua : 16.3” . www.lua.org . Récupéré le 16 septembre 2021 .
^ “wiki lua-users : Tutoriel sur les métaméthodes” . lua-users.org . Récupéré le 16 septembre 2021 .
^ Ierusalimschy, R.; Figueiredo, LH; En ligneCeles, W. (2005). “La mise en œuvre de Lua 5.0” . J. de Universal Comp. Sci . 11 (7): 1159–1176.
^ Texas Instruments (1990). PC Scheme : Guide de l’utilisateur et manuel de référence du langage, édition commerciale . ISBN 0-262-70040-9.
^ Kein-Hong Man (2006). “Une introduction sans fioritures aux instructions de la machine virtuelle Lua 5.1” (PDF) .
^ ^un ^b “Manuel de référence Lua 5.2” . Lua.org . Récupéré le 23 octobre 2012 .
^ “Modifications dans l’API” . Manuel de référence Lua 5.2 . Lua.org . Récupéré le 9 mai 2014 .
^ “Lua Rocks” . Wiki LuaRocks . Récupéré le 24 mai 2009 .
^ “Code de liaison à Lua” . Wiki des utilisateurs de Lua . Récupéré le 24 mai 2009 .
^ “Pourquoi Lua est-il considéré comme un langage de jeu ?” . Archivé de l’original le 20 août 2013 . Récupéré le 22 avril 2017 . {{cite web}}: CS1 maint : bot : état de l’URL d’origine inconnu ( lien )
^ “Pourquoi Luau?” . Luau . Récupéré le 23 mars 2022 .
^ “TIL Angry Birds a été codé en Lua – post – Imgur” . Récupéré le 23 mars 2022 .
^ “Introduction au modding côté serveur Crysis” . Récupéré le 23 mars 2022 .
^ “Fonctions Lua” . wow.gamepedia.com . Récupéré le 1er mars 2021 .
^ “Résultats du sondage” . Archivé de l’original le 7 décembre 2003 . Récupéré le 22 avril 2017 . {{cite web}}: CS1 maint : bot : état de l’URL d’origine inconnu ( lien )
^ “Les gagnants du prix de première ligne sont annoncés” . Archivé de l’original le 15 juin 2013 . Récupéré le 22 avril 2017 . {{cite web}}: CS1 maint : bot : état de l’URL d’origine inconnu ( lien )
^ “Extension : Scribunto – MediaWiki” . MediaWiki.org . Récupéré le 21 février 2019 .
^ “Wikidata : Tutoriel Infobox – Wikidata” . www.wikidata.org . Récupéré le 21 décembre 2018 .
^ “Guide des langues – MoonScript 0.5.0” . moonscript.org . Récupéré le 25 septembre 2020 .
^ feuille (23 septembre 2020), leafo/moonscript , récupéré le 25 septembre 2020
^ ^un ^b André Alves Garzia. “Langages qui compilent en Lua” . AndreGarzia.com . Récupéré le 25 septembre 2020 .
^ “Urn : Une implémentation Lisp pour Lua | Urn” . urne-lang.com . Récupéré le 12 janvier 2021 .
^ “Amulette ML” . amulette.fonctionne . Récupéré le 12 janvier 2021 .
^ “Luau” . Roblox.GitHub.io .
^ “Langage de programmation Ravi” . GitHub .
^ Hundt, Richard (22 avril 2021). “richardhundt/briller” . GitHub .
^ “Patches de puissance Lua” . lua-users.org .

Lectures complémentaires

En ligneIerusalimschy, R. (2013). Programmation en Lua (3e éd.). Lua.org. ISBN 978-85-903798-5-0.(La 1ère éd. est disponible en ligne .)
Gutschmidt, T. (2003). Programmation de jeux avec Python, Lua et Ruby . Cours Technologie PTR. ISBN 978-1-59200-077-7.
Schuytema, P.; En ligneManyen, M. (2005). Développement de jeux avec Lua . Charles River Media. ISBN 978-1-58450-404-7.
Jung, K.; En ligneBrown, A. (2007). Début de la programmation Lua . Presse Wrox . ISBN 978-0-470-06917-2. Archivé de l’original le 8 juillet 2018 . Récupéré le 7 juillet 2018 .
Figueiredo, LH; Celes, W.; Ierusalimschy, R., éd. (2008). Gemmes de programmation Lua . Lua.org. ISBN 978-85-903798-4-3.
Takhteyev, Yuri (2012). Coding Places: Software Practice in a South American City . La presse du MIT . ISBN 978-0-262-01807-4. Archivé de l’original le 2 novembre 2012.Les chapitres 6 et 7 sont consacrés à Lua, tandis que d’autres examinent plus largement les logiciels au Brésil.
Varma, Jayant (2012). Apprenez Lua pour le développement de jeux iOS . Apress . ISBN 978-1-4302-4662-6.
Matheson, Ash (29 avril 2003). “Une introduction à Lua” . GameDev.net . Archivé de l’original le 18 décembre 2012 . Récupéré le 3 janvier 2013 .
Fieldhouse, Keith (16 février 2006). “Présentation de Lua” . ONLamp.com . O’Reilly Media . Archivé de l’original le 12 mars 2006 . Récupéré le 28 février 2006 .
Streicher, Martin (28 avril 2006). “Scripts intégrables avec Lua” . développeurWorks . IBM . Archivé de l’original le 2 juillet 2009 . Récupéré le 7 juillet 2018 .
Quigley, Joseph (1er juin 2007). “Un regard sur Lua” . Revue Linux .
Hamilton, Naomi (11 septembre 2008). “L’AZ des langages de programmation : Lua” . Monde informatique . IDG . Archivé de l’original le 8 juillet 2018 . Récupéré le 7 juillet 2018 .Entretien avec Roberto Ierusalimschy.
Ierusalimschy, Roberto; de Figueiredo, Luiz Henrique; Celes, Waldemar (12 mai 2011). “Passer une langue par le chas d’une aiguille” . File d’attente ACM . 9 (5): 20–29. doi : 10.1145/1978862.1983083 . S2CID 19484689 .Comment l’intégration de Lua a eu un impact sur sa conception.
Ierusalimschy, Roberto; de Figueiredo, Luiz Henrique; Celes, Waldemar (novembre 2018). “Un regard sur la conception de Lua” . Communications de l’ACM . 61 (11): 114–123. doi : 10.1145/3186277 . S2CID 53114923 .^{[ lien mort permanent ]}
Articles et thèses Lua