Apprendre le Lua

Lua est un langage de script développé au Brésil au début des années 1990. Le code source d’un programme en Lua est traduit et exécuté sous forme de code byte par un in­ter­pré­teur Lua. L’in­ter­pré­teur lui-même est codé en C, ce qui permet aux pro­grammes en Lua de disposer d’une per­for­mance élevée lors de l’exécution. Par ailleurs, l’API C permet d’intégrer le code Lua dans les pro­grammes C/C++. Le Lua est un langage mul­ti­pa­ra­digmes per­met­tant d’écrire du code impératif, fonc­tion­nel et orienté objet.

La prin­ci­pale ca­rac­té­ris­tique dis­tinc­tive du Lua est son in­té­gra­tion simple dans d’autres systèmes et langages. Le Lua s’est ainsi établi comme un « langage glue » et est utilisé dans de nombreux moteurs de jeux. Ce langage peut en outre être utilisé pour commander des serveurs Web comme Apache et nginx. Via l’interface CGI, le Lua est, d’autre part, souvent utilisé comme langage de pro­gram­ma­tion Internet in­dé­pen­dant. Par ailleurs, ce langage in­ter­vient également dans la pro­gram­ma­tion d’ap­pli­ca­tions mobiles.

L’in­ter­pré­teur Lua est composé d’un unique fichier binaire dis­po­nible dans l’invite de commande sous la commande « lua ». Ce fichier est en­re­gis­tré sur le système et doit le cas échéant être intégré dans le chemin. Lua propose également des bi­blio­thèques per­met­tant l’in­té­gra­tion de code Lua dans les pro­grammes C/C++.

Pour l’ins­tal­la­tion sous Mac et Linux, l’ins­tal­la­tion devra être réalisée à l’aide du ges­tion­naire de paquets « Homebrew ». Après avoir installé Homebrew sur votre système, utilisez la commande suivante dans l’invite de commande pour installer Lua :

Pour installer Lua sur un système Windows, utilisez l’ins­tal­la­teur LuaDist.

Comme pour de nombreux autres langages de script, l’in­ter­pré­teur Lua peut être exécuté de façon in­te­rac­tive. En mode in­te­rac­tif, l’in­ter­pré­teur reçoit le code Lua dans l’invite de commande et l’exécute ligne après ligne. Les valeurs ainsi générées sont di­rec­te­ment indiquées dans l’invite de commande. En tant qu’uti­li­sa­teur, vous avez la pos­si­bi­lité de vérifier et de modifier les valeurs des variables. Cette approche convient donc tout par­ti­cu­liè­re­ment à un pro­to­ty­page rapide. Pour démarrer l’in­ter­pré­teur Lua en mode in­te­rac­tif, nous exécutons la commande suivante dans l’invite de commande :

Plutôt que de saisir pro­gres­si­ve­ment le code Lua dans l’invite de commande, vous pouvez également indiquer à l’in­ter­pré­teur Lua d’exécuter un fichier de code source Lua complet. Pour ce faire, nous devons tout d’abord générer un fichier Lua et trans­mettre à l’in­ter­pré­teur Lua le nom du fichier. L’in­ter­pré­teur lit le code source inclut dans le fichier ligne après ligne et les exécute.

Sur le système d’ex­ploi­ta­tion Linux/UNIX/macOS, nous avons également la pos­si­bi­lité de rendre di­rec­te­ment exé­cu­table un fichier de code source Lua. Pour ce faire, il nous faut saisir un « shebang » à la première ligne du fichier Lua :

Comme vous pouvez le constater, le shebang contient l’em­pla­ce­ment de stockage du fichier binaire Lua, dans notre cas « #!/usr/local/bin/lua ». Dans certains cas, l’em­pla­ce­ment de stockage sur votre système local peut être différent. Vous pouvez alors dé­ter­mi­ner le lieu de stockage du fichier binaire Lua en utilisant la commande « which » dans l’invite de commande :

Après avoir doté le script Lua d’un shebang, vous devez marquer le fichier comme exé­cu­table par l’uti­li­sa­teur. Pour cela, utilisez la commande suivante dans l’invite de commande :

Exécutez ensuite le script Lua dans le ré­per­toire actuel :

Lua est un langage mul­ti­pa­ra­digmes : le style sur lequel il est basé est impératif et fonc­tion­nel. Ce langage est com­plè­te­ment dynamique, ce qui signifie qu’aucune dis­tinc­tion n’est opérée entre « compile time » et « run time ». Lua s’appuie uni­que­ment sur une gestion dynamique de la mémoire : la taille d’un objet dans la mémoire peut évoluer au cours du processus. Un « Garbage Collector » (GC) libère l’espace disque qui n’est plus né­ces­saire de façon à épargner cette tâche au pro­gram­meur.

Les com­men­taires sont des éléments es­sen­tiels dans tous les langages de pro­gram­ma­tion. Ils sont notamment utilisés pour :

• esquisser les éléments de code,
• do­cu­men­ter les fonc­tion­na­li­tés du code,
• activer/dé­sac­ti­ver les lignes de code.

En Lua, un com­men­taire d’une ligne commence avec un double tiret (--) et se poursuit jusqu’à la fin de la ligne :

En les combinant avec des doubles crochets « [[ » et « ]] », il est également possible d’écrire des com­men­taires multiples :

À l’instar de la plupart des autres langages de script, Lua est également un langage dynamique stan­dar­disé. Les types ne relèvent pas des variables mais des valeurs. Chaque valeur dispose pré­ci­sé­ment d’un type, qu’il s’agisse d’un nombre, d’une séquence de ca­rac­tères, d’une valeur logique, etc. Au total, Lua dispose d’un nombre de types gérable. Ils sont résumés dans l’aperçu suivant :

Lua connaît la syntaxe littérale pour les valeurs de tous les types à l’exception de « thread » et « userdata ». Pour dé­ter­mi­ner le type d’une valeur, on utilise la fonction « type() ». Cette fonction indique le nom du type sous forme de chaîne de ca­rac­tères. Voici quelques exemples :

Une ex­pres­sion est évaluée par l’in­ter­pré­teur et fournit une valeur. Les ex­pres­sions associent des littéraux, des opé­ra­teurs, des variables et des appels de fonctions. Les ex­pres­sions peuvent également être groupées avec des pa­ren­thèses « () ». En tant que langage dynamique, Lua détermine au­to­ma­ti­que­ment le type de la valeur fournie. Voici plusieurs exemples d’ex­pres­sions :

Une variable est un nom pour une valeur dans la mémoire. Comme dans la plupart des langages de pro­gram­ma­tion, en Lua, un nom commence avec une lettre ou un tiret bas (_) suivi par d’autres lettres, tirets ou chiffres. Dans ce cas, on opère une dis­tinc­tion stricte entre les ma­jus­cules et les mi­nus­cules. Les mots réservés ci-dessous ne peuvent pas être utilisés seuls comme nom :

« and », « end », « in », « repeat », « break », « false », « local », « return », « do », « for », « nil », « then », « else », « function », « not », « true », « elseif », « if », « or », « until », « while »

Toutefois, ces mots réservés peuvent tout à fait être utilisés comme partie d’un nom :

L’at­tri­bu­tion d’une valeur à une variable est effectuée à l’aide de l’opérateur d’at­tri­bu­tion (=). Celui-ci ne doit pas être confondu avec l’opérateur logique d’équi­va­lence (==). Lors de l’at­tri­bu­tion, on opère comme d’habitude une dis­tinc­tion entre « L-value » et « R-value » : la variable doit se trouver à gauche de l’opérateur d’at­tri­bu­tion, il s’agit de la L-value. Cette variable est attribuée à la valeur évaluée de la R-value située à droite :

Un opérateur génère une nouvelle valeur à partir d’une ou plusieurs opérande(s). On parle alors d’opérateur unaire (à un chiffre) ou binaire (à deux chiffres). Un opérateur associe les opérandes d’un type donné et fournit une valeur d’un certain type. Jetons un œil aux dif­fé­rents opé­ra­teurs en Lua.

Les opé­ra­teurs arith­mé­tiques opèrent sur des nombres et donnent un nombre :

Tous les opé­ra­teurs re­la­tion­nels sont binaires et testent la façon dont deux opé­ra­teurs se com­por­tent l’un par rapport à l’autre. Ils donnent une valeur logique :

Les opé­ra­teurs logiques associent des valeurs logiques et donnent une nouvelle valeur logique :

Il existe deux autres opé­ra­teurs spé­ci­fiques en Lua. Ils servent à la con­ca­té­na­tion de chaînes de ca­rac­tères (c’est-à-dire à leur en­chaî­ne­ment) ainsi qu’à la dé­ter­mi­na­tion de la puissance d’une valeur composée comme une table ou une chaîne de ca­rac­tères :

Con­trai­re­ment à de nombreux langages de script, Lua ne reconnaît pas les opé­ra­teurs d’at­tri­bu­tion composés comme « += » et « -= ». Pour in­cré­men­ter et dé­cré­men­ter des variables, l’opération doit être écrite de façon explicite :

Le concept de portée est un concept central dans tous les langages de pro­gram­ma­tion. Une variable n’existe que dans une certaine portée lexicale. Comme en Ja­vaS­cript, en Lua, les variables sont globales par défaut. Toutefois, l’uti­li­sa­tion gé­né­ra­li­sée de variables globales est connue comme un « anti-modèle » qu’il convient d’éviter. En Lua, le mot-clé « local » fournit une solution. Il permet de limiter la portée d’une variable au bloc englobant, de façon similaire à la dé­cla­ra­tion via « let » dans Ja­vaS­cript.

En Lua, les corps des fonctions et des boucles ouvrent une nouvelle portée. D’autre part, le Lua utilise le concept du bloc explicite. Un bloc définit une nouvelle portée pour le code situé entre les mots-clés « do » et « end ». Dans Java/C/C++, cela cor­res­pond aux accolades ouvrantes/fermantes « { » et « } ». L’exemple de code suivant illustre la manière dont les blocs, les portées et les variables fonc­tion­nent ensemble :

Le Lua connaît les struc­tures de contrôle ha­bi­tuelles que l’on retrouve dans d’autres langages de pro­gram­ma­tion. Ces struc­tures incluent les boucles et les ra­mi­fi­ca­tions. Voici un exemple d’ins­truc­tions « if », « then », « else », « elseif » pour Lua :

Outre la boucle « while » classique, le Lua connaît également sa con­tre­par­tie « repeat »-« until ». Cette ins­truc­tion existe également dans Ruby. Elle exige l’inversion de la condition utilisée. Cela signifie qu’un « while » avec la condition « nombre </= limit » cor­res­pond à un « repeat »-« until » avec la condition « nombre > limit ». Attention avec l’ins­truc­tion « repeat » ! Quelle que soit la condition, le corps de la boucle est exécuté au minimum une fois. Voici un exemple :

À l’instar de la plupart des langages de pro­gram­ma­tion im­pé­ra­tifs, le Lua connaît également l’ins­truc­tion « for » en plus de la boucle « while ». Deux formes sont utilisées ici : une variante similaire à C avec une variable de boucle ainsi qu’une variante avec itérateur. Regardons tout d’abord l’uti­li­sa­tion de l’ins­truc­tion « for » avec la variable de boucle :

De façon sur­pre­nante, la variable de boucle définie dans la boucle « for » est locale et non globale, sans qu’il soit pour autant né­ces­saire de la déclarer ex­pli­ci­te­ment comme « locale ». C’est logique et, à cet égard, le Lua se démarque po­si­ti­ve­ment du Ja­vaS­cript. En Ja­vaS­cript, une variable de boucle déclarée sans « let » ou « var » est globale, ce qui peut entraîner des erreurs sérieuses.

Regardons à présent la boucle « for » avec un itérateur en Lua. Sur le principe, l’approche ressemble à celle de Python : au lieu d’in­cré­men­ter une variable de boucle et de l’utiliser comme index dans une liste, nous itérons di­rec­te­ment via les éléments de la liste. Pour générer l’itérateur, on utilise souvent la fonction « ipairs() ». Voici un exemple :

De la même façon qu’en C/C++, Java et Ja­vaS­cript, les fonctions sont définies avec le mot-clé « function ». Comme à l’ac­cou­tu­mée, les noms des fonctions sont suivis de leurs pa­ra­mètres entre pa­ren­thèses. La par­ti­cu­la­rité du Lua réside dans le fait qu’en cas d’appel d’une fonction avec pré­ci­sé­ment un littéral comme argument, il est possible d’omettre les pa­ren­thèses. En Lua, une fonction ne doit pas im­pé­ra­ti­ve­ment donner une valeur. Par dé­fi­ni­tion, une fonction sans valeur est une « procédure » :

Si l’on souhaite obtenir une valeur à partir d’une fonction, il convient d’utiliser le mot-clé « return » comme à l’ac­cou­tu­mée. Ce mot-clé met fin à l’exécution de la fonction et donne la valeur indiquée. Dans l’exemple de code suivant, un chiffre est mis au carré :

Comme en Python et en Ja­vaS­cript, en Lua, une fonction peut recevoir un nombre variable d’arguments. Les arguments sont en­re­gis­trés dans une cons­truc­tion spéciale « (...) ». Pour accéder aux arguments, il est souvent utile de les ras­sem­bler dans une liste avec l’ex­pres­sion « {...} ». Il est également possible d’utiliser la fonction « select() » qui extrait un argument sous l’index indiqué. Le nombre d’arguments est déterminé avec l’ex­pres­sion « #{...} ».

Outre un nombre variable d’arguments, le Lua permet également de fournir plusieurs valeurs avec une ins­truc­tion « return ». Le processus fonc­tionne à peu de chose près comme en Python, toutefois sans le type explicite « Tupel ». Comme en Python, il est fréquent d’attribuer plusieurs variables à la valeur de retour en cas d’appel de fonction. Voici un exemple :

Si l’une des valeurs de retour n’est pas né­ces­saire, selon une con­ven­tion usuelle, on utilise le tiret bas (_) comme balise, comme dans l’exemple suivant :

En Lua, les fonctions sont des « first-class citizens ». Cela signifie qu’elles peuvent être rat­ta­chées à des variables et peuvent également être trans­mises à d’autres fonctions comme arguments. D’autre part, une fonction peut servir de valeur de retour d’une fonction. Pris dans son ensemble, le Lua permet donc une pro­gram­ma­tion fonc­tion­nelle, illustrée ici par l’exemple de la célèbre fonction « map() » :

En pro­gram­ma­tion fonc­tion­nelle, on utilise souvent la ré­cur­si­vité qui fait qu’une fonction s’appelle sans cesse elle-même avec des arguments modifiés. Dans le cas du Lua, il convient de faire preuve d’une attention par­ti­cu­lière à cet égard. Les fonctions appelées de façon récursive doivent être ex­pli­ci­te­ment déclarées comme « local ».