Langage de programmation Lua : guide du débutant

Lua, qui signifie « lune » en portugais, est un langage de programmation léger et polyvalent, parfaitement adapté aux débutants comme aux développeurs expérimentés.

En plus d’être compact, efficace et capable d’accomplir des tâches très variées, Lua est réputé pour sa simplicité et sa facilité d’intégration avec d’autres langages de programmation, en particulier C et C++.

Si vous préférez un format vidéo, regardez notre présentation sur le même sujet : « Langage de programmation Lua : guide du débutant ».

Premiers pas avec Lua

Pourquoi choisir Lua ?

• Léger et rapide : Lua a été conçu pour rester compact et efficace, ce qui en fait un choix idéal pour les systèmes embarqués et les applications où la performance est déterminante. Il occupe très peu de mémoire et s’exécute rapidement.
• Facile à apprendre : la syntaxe directe de Lua et son design minimaliste permettent aux débutants de s’y mettre et de coder rapidement.
• Extensible : Lua s’intègre facilement à d’autres langages de programmation, notamment C et C++. C’est donc un outil puissant pour ajouter des capacités de scripting à des applications existantes.
• Polyvalent : Lua prend en charge plusieurs paradigmes de programmation, dont la programmation procédurale, orientée objet et fonctionnelle. Les développeurs peuvent ainsi adopter le style qui correspond le mieux à leurs besoins.
• Le scripting Lua dans le développement de jeux : Lua est très largement utilisé dans l’industrie du jeu vidéo pour scripter la logique de jeu, grâce à sa rapidité et à sa flexibilité. Des plateformes populaires comme Roblox (qui utilise Luau, un sur-ensemble typé de Lua), LÖVE 2D, Defold et World of Warcraft s’appuient sur Lua ou sur du scripting dérivé de Lua pour la logique de jeu et le modding.
• Luau (le dialecte Lua de Roblox): puisqu’on parle de jeu vidéo, avec des dizaines de millions d’utilisateurs actifs quotidiens sur Roblox, Luau, un sur-ensemble typé et optimisé pour la performance de Lua 5.1, constitue l’un des environnements de scripting les plus utilisés au monde. Vos compétences Lua sont donc directement transposables à l’une des plus grandes plateformes de jeu.
• Une communauté et des ressources actives : Lua bénéficie d’une communauté active et solidaire, qui met à disposition une multitude de bibliothèques, d’outils et de documentation. Les développeurs trouvent ainsi plus facilement de l’aide et des ressources au fil de leur apprentissage et de leur travail avec le langage.

Comment installer Lua

Windows

1. Téléchargez les binaires Lua depuis le site officiel de Lua.
2. Extrayez les fichiers dans le répertoire de votre choix.
3. Ajoutez le répertoire Lua à la variable d’environnement PATH de votre système.
4. Ouvrez une invite de commandes et saisissez « lua -v » pour vérifier que l’installation a réussi.

macOS

1. Ouvrez le Terminal.
2. Installez Homebrew si ce n’est pas déjà fait, à l’aide de cette commande :
   /bin/bash -c “$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)”
3. Utilisez Homebrew pour installer Lua : « brew install lua ».
4. Vérifiez l’installation en saisissant « lua -v » dans le Terminal.

Linux

1. Ouvrez le Terminal.
2. Utilisez le gestionnaire de paquets pour installer Lua. Sur les systèmes basés sur Debian, saisissez : « sudo apt-get install lua5.5 ».
3. Vérifiez l’installation avec « lua -v ».

Ce guide s’appuie sur Lua 5.5, la version stable actuelle, dont les principales nouveautés sont « les déclarations de variables globales, les tables vararg nommées, des tableaux plus compacts et des collectes majeures effectuées de façon incrémentale ».

Configurer l’environnement de développement

Configurer son environnement de développement, c’est comme ranger son espace de travail avant de démarrer un nouveau projet : une installation propre et bien pensée rend le développement plus productif.

Vous pouvez utiliser n’importe quel éditeur de texte ou EDI (environnement de développement intégré) pour développer en Lua. Parmi les choix les plus répandus : Visual Studio Code, Sublime Text et Neovim (qui utilise Lua comme langage de configuration natif). Veillez à installer une extension ou un plugin Lua pour bénéficier de la coloration syntaxique et d’autres fonctionnalités.

Écrire et exécuter votre premier programme Lua

Commençons par un simple programme « Hello, World ! » :

print("Hello, World!")

Pour l’exécuter, enregistrez-le sous le nom « hello.lua », puis lancez-le depuis la ligne de commande :

lua hello.lua

Syntaxe et notions de base de Lua

La syntaxe de Lua est directe et facile à assimiler. Voici quelques notions fondamentales.

Variables et types de données

En Lua, les variables sont des conteneurs qui stockent des données. Lua est typé dynamiquement : vous n’avez pas besoin de déclarer le type d’une variable.

local num = 42 -- number
local str = "Hello" -- string
local bool = true -- boolean

Opérateurs et expressions

Les opérateurs servent à effectuer des opérations sur les variables :

local sum = 10 + 5 — arithmetic
local isEqual = (10 == 5) — comparison
local andOp = (true and false) — logical

Structures de contrôle

Les structures de contrôle dirigent le déroulement de votre programme :

if num > 40 then
print("Number is greater than 40")
else
print("Number is 40 or less")
end
for i = 1, 5 do
print(i)
end
while num > 0 do
print(num)
num = num - 1
end

Les fonctions en Lua

Une fonction regroupe un ensemble d’instructions réutilisables à volonté.

Définir et appeler des fonctions Lua

Voici comment définir une fonction simple :

function greet(name)
print("Hello, " .. name)
end
greet("Alice")

Portée et durée de vie des fonctions

Les variables déclarées à l’intérieur d’une fonction sont locales à celle-ci et cessent d’exister dès que la fonction se termine.

function add(a, b)
local sum = a + b
return sum
end

Fonctions d’ordre supérieur et closures

Les fonctions d’ordre supérieur et les closures relèvent de techniques avancées. Elles permettent de traiter les fonctions comme des variables et de créer des comportements complexes.

function makeAdder(x)
return function(y)
return x + y
end
end
local addFive = makeAdder(5)
print(addFive(10)) — Output : 15

Les tables : le cœur de Lua

Les tables constituent la structure de données centrale de Lua et sont indispensables à de nombreuses opérations. Les tables Lua sont polyvalentes : elles peuvent servir de tableaux, de dictionnaires, voire d’objets.

Créer et manipuler des tables

Créer une table est simple :

local fruits = {"apple", "banana", "cherry"}
local person = {name = "John", age = 30}

Les manipuler est tout aussi facile :

table.insert(fruits, "orange")
print(fruits[4]) -- Output: orange
person.job = "developer"
print(person.name) -- Output: John

Utiliser les tables comme tableaux et comme dictionnaires

Les tables peuvent faire office de tableaux comme de dictionnaires :

• Table de type tableau

local numbers = {1, 2, 3, 4, 5}

• Table de type dictionnaire

local capitals = {USA = "Washington, D.C.", France = "Paris"}

print(capitals["USA"]) -- Output: Washington, D.C.

Gestion des erreurs et débogage

La gestion des erreurs en Lua, c’est comme avoir une trousse de premiers secours à portée de main : on espère ne jamais en avoir besoin, mais elle devient essentielle le moment venu.

Types d’erreurs courants et comment les traiter

Les erreurs peuvent avoir des origines diverses : erreurs de syntaxe, erreurs d’exécution ou erreurs de logique. Lua fournit des mécanismes pour les gérer proprement grâce à pcall (appel protégé).

local status, err = pcall(function()
-- code that might fail
end)
if not status then
print("Error: " .. err)
end

Techniques et outils de débogage

Le débogage prend tout son sens lorsqu’il faut identifier et corriger les problèmes de façon méthodique. Lua intègre une bibliothèque debug qui rend l’exercice relativement simple.

function debug.traceback([message[, level]])
-- usage
end
debug.sethook(function(event, line)
local s = debug.getinfo(2).short_src
print(s .. ":" .. line)
end, "l")

Bonnes pratiques pour écrire du code Lua robuste

Le souci du détail et le respect des bonnes pratiques font toute la différence.

• Donnez des noms explicites à vos variables.
• Découpez votre code en modules.
• Évitez les variables globales afin que votre code reste maintenable et moins sujet aux erreurs.

Travailler avec les modules et bibliothèques Lua

Les bibliothèques et les modules Lua sont des outils spécialisés : ils apportent des fonctionnalités supplémentaires et simplifient les tâches complexes.

Les bibliothèques standard de Lua

Lua est livré avec plusieurs bibliothèques intégrées qui couvrent un large éventail de fonctionnalités : manipulation de chaînes, opérations mathématiques, entrées/sorties de fichiers, etc.

local str = "Hello, World!"
print(string.lower(str)) -- Output: hello, world!
local sum = math.max(1, 2, 3, 4, 5)
print(sum) -- Output: 5

Comment utiliser et créer des modules

Les modules Lua vous permettent d’organiser votre code en composants réutilisables.

Créer un module

-- mymodule.lua
local M = {}
function M.greet(name)
print("Hello, " .. name)
end
return M

Utiliser un module

local mymodule = require("mymodule")
mymodule.greet("Alice")

Bibliothèques tierces populaires

Lua dispose d’un riche écosystème de bibliothèques tierces qui étendent ses capacités. Voici quelques-unes des plus connues :

• LuaSocket pour la communication réseau
• LuaFileSystem pour les opérations sur le système de fichiers
• Penlight pour les fonctions utilitaires

Applications concrètes de Lua

Les usages de Lua vont des systèmes embarqués au développement de jeux, et bien au-delà.

• Systèmes embarqués et IdO (internet des objets) :
  la légèreté de Lua en fait un choix idéal pour les systèmes embarqués et les appareils IdO. Il offre de puissantes capacités de scripting sans consommer beaucoup de mémoire ni de puissance de calcul.
• Scripting et automatisation :
  Lua est fréquemment utilisé pour le scripting et l’automatisation informatique, ce qui permet d’automatiser les tâches répétitives et d’étendre les fonctionnalités des applications.

Sujets avancés

Pour ceux qui souhaitent aller plus loin, Lua propose des fonctionnalités avancées : métatables, métaméthodes, coroutines et intégration avec du code C/C++.

• Métatables et métaméthodes :
  les métatables et les métaméthodes sont le moyen offert par Lua de personnaliser le comportement des tables.
• Coroutines et concurrence :
  les coroutines offrent un moyen puissant de gérer les tâches asynchrones, en permettant un multitâche coopératif sans la complexité des threads.
• Intégration avec du code C/C++ :
  Lua peut être embarqué dans des applications C/C++ et y fournir une interface de scripting flexible.

En résumé

Lua est un langage de programmation polyvalent et puissant, facile à apprendre et agréable à utiliser. En maîtrisant ses notions de base, sa syntaxe et ses domaines d’application, vous pouvez vous lancer dans la programmation en Lua en toute confiance.

N’oubliez pas qu’apprendre un nouveau langage demande de la pratique et de la patience. Si vous souhaitez poursuivre votre apprentissage, découvrez « Learn Lua in 15 Minutes », un tutoriel Lua pour débutants, qui est aussi une application Lua que vous pouvez réellement exécuter.

Continuez à expérimenter, à créer des projets et à explorer les nombreuses ressources disponibles pour aller plus loin.