Lua vs Bash : guide pratique, exemples et critères concrets

Informatec Digital » Expressions idiomatiques » Lua vs Bash : guide pratique, exemples et critères concrets

L'automatisation et le scripting sont monnaie courante sous Unix et les systèmes de type Unix, mais aussi dans les environnements mixtes avec Windows. La comparaison récurrente entre Bash et Lua surgit lorsqu'on recherche un compromis entre vitesse, portabilité et facilité de maintenance.

En nous basant sur les sources les plus pertinentes (articles présentant Lua comme une alternative polyvalente à Bash , guides pratiques sur Mako Server, discussions de forums et avis favorables à Bash), nous organiserons les idées, fournirons des exemples et mettrons en lumière les pièges courants, comme la fameuse erreur 127 lors de l'exécution de Lua depuis Bash sous Windows (Git Bash). Nous contextualiserons également le sujet en mentionnant d'autres langages présents dans les sources (JavaScript, Python, Node.js, HTML5, PHP) et en incluant la mention relative aux cookies sur Reddit, visible par de nombreux utilisateurs lors de l'ouverture de discussions.

Que sont Bash et Lua

En résumé, Bash (Bourne Again Shell) est l'interpréteur de commandes par excellence pour les systèmes de type Unix : il interprète les commandes, orchestre les utilitaires et permet d'enchaîner les processus à l'aide de tubes et de redirections. Son objectif principal est d'être un interpréteur de commandes puissant doté d'une couche de programmation permettant de combiner des commandes.

Lua est un langage léger, rapide et intégrable, multiplateforme et doté d'une syntaxe claire. Sa conception minimaliste lui permet de fonctionner sur des ressources limitées et au sein d'applications (moteurs de jeu, outils réseau, serveurs embarqués), offrant des structures de contrôle modernes et un type de données composite unique : la table.

• Frapper: idéal pour le traitement de texte, la manipulation de fichiers et l'administration système en tirant parti de l'ensemble de l'écosystème des utilitaires POSIX.
• Lua: langage généraliste et intégrable ; offre plus d'expressivité et contrôle pour une logique complexe, tout en conservant un faible encombrement et une grande portabilité.

Principales différences entre les scripts et l'automatisation

Plusieurs entrées du classement soulignent ce point : Lua se distingue par sa légèreté et sa rapidité . Sa machine virtuelle est compacte et l’interpréteur démarre rapidement, ce qui est appréciable pour les scripts exécutés fréquemment ou dans les environnements embarqués.

La portabilité est un autre atout majeur. Lua n'est pas limité à Unix : il fonctionne parfaitement sous Linux, macOS et Windows, minimisant ainsi les instructions conditionnelles spécifiques à chaque plateforme. Bash, bien qu'utilisable sous Windows via des émulateurs (Git Bash, WSL), repose davantage sur les outils POSIX et les spécificités de l'environnement.

En termes d'expressivité, Lua offre des fonctions de premier ordre , des coroutines et des métatables. Ces outils permettent de construire des solutions plus complètes sans recourir à des utilitaires externes, alors qu'en Bash, il est courant de composer la solution avec sed, awk, grep, find, etc. Bash excelle précisément dans cet écosystème et dans la manipulation des pipes.

Apprentissage et lisibilité

Plusieurs guides soulignent que la syntaxe de Lua ressemble à du pseudocode , ce qui facilite la tâche des débutants. Bash, en revanche, possède des règles de citation, d'expansion et de substitution qui peuvent surprendre. Deux exemples équivalents (boucle de 1 à 5) :

# Bash
#!/usr/bin/env bash
for i in {1..5}; do
  echo 'Hola, mundo '"$i"
done

-- Lua
for i = 1, 5 do
  print('Hola, mundo ' .. i)
end

La version Lua est simple et moins sujette aux erreurs liées aux guillemets ou à une expansion inhabituelle. En Bash, il est essentiel de maîtriser l'utilisation des guillemets simples et doubles, ainsi que le fonctionnement des variables et des accolades.

Fonctionnalités avancées de Lua pour l'automatisation

Fonctions de première classe : elles sont stockées dans des variables, passées comme arguments et renvoyées ; elles favorisent la modularité et la réutilisation dans les automatisations de complexité moyenne/élevée.

Les coroutines permettent d'exécuter des tâches concurrentes non bloquantes sans avoir recours aux threads du système d'exploitation. Elles sont très utiles pour coordonner les flux de travail (par exemple, plusieurs opérations d'entrée/sortie) sans complexifier les processus.

Métatables et métaméthodes : permettent de redéfinir le comportement des opérations sur les tables, étendant ainsi le langage pour l'adapter au domaine du problème.

Un exemple simple et fréquemment cité dans les articles : le traitement de fichiers ligne par ligne en Lua, de manière concise et claire :

-- Lua: leer y procesar un archivo línea a línea
local function procesar(archivo)
  local f = io.open(archivo, 'r')
  for linea in f:lines() do
    print('Procesando: ' .. linea)
  end
  f:close()
end
procesar('ejemplo.txt')

Ce modèle montre comment Lua combine des entrées/sorties simples avec clarté ; il est facile de l'étendre pour analyser, filtrer ou communiquer avec d'autres composants.

Lua en pratique : serveur Mako pour les scripts modernes

L'un des guides les mieux notés suggère d'utiliser Mako Server pour étendre Lua avec des API orientées automatisation (y compris la gestion du réseau), réduisant ainsi la dépendance aux bibliothèques externes. Le code typique serait :

#!/usr/bin/env mako
print('Hola Lua!')

Installation sur Linux x86-64 (selon le tutoriel) : rapide et facile.

cd /tmp
wget makoserver.net/download/mako.linux-x64.tar.gz
tar xvzf mako.linux-x64.tar.gz
sudo cp mako mako.zip /usr/local/bin/

Une fois installé, le script s'exécute normalement et tire parti des API supplémentaires de Mako . Par exemple, il permet de créer des routes et de lister du contenu grâce à des appels système.

#!/usr/bin/env mako
os.execute('mkdir -p api/os api/fs')
os.execute('ls -lh api')

Si vous avez besoin de fonctionnalités Bash (par exemple, l'expansion des touches), vous pouvez les invoquer depuis Lua et préserver l'ergonomie :

#!/usr/bin/env mako
local function ex(cmd)
  -- Usa bash como login shell y escapa el comando
  return os.execute('/bin/bash -lc ' .. string.format('%q', cmd))
end
ex('mkdir -p api/{os,fs}')
ex('ls -lh api')

Pour capturer la sortie standard (et pas seulement le code de sortie), la fonction io.popen est très utile. Une pratique courante consiste à obtenir les versions binaires :

#!/usr/bin/env mako
local function ex(cmd)
  local p = io.popen(cmd)
  local out = p:read('*a') or ''
  p:close()
  return (out:gsub('%s+$',''))
end
local function version(s)
  return s:match('([%d]+%.[%d]+%.[%d]+)')
end
local nodev = version(ex('node --version'))
print('node version\t' .. (nodev or 'not installed'))
local wgetv = version(ex('wget -V'))
print('wget version\t' .. (wgetv or 'not installed'))

Voici comment créer des vérifications de dépendances simples sans quitter Lua, tout en conservant un flux clair et portable.

Paquets externes avec Mako : exemple avec luash

Autre recommandation populaire : luash , une bibliothèque légère qui simplifie l’exécution des commandes système depuis Lua grâce à une API rappelant celle du shell. Installation typique :

git clone https://github.com/zserge/luash.git
sudo mkdir -p /usr/local/share/lua/5.4/
sudo cp luash/sh.lua /usr/local/share/lua/5.4/

Un court script listant le répertoire courant ressemblerait à ceci, mêlant des syntaxes Lua idiomatiques à des appels de type shell :

#!/usr/bin/env mako
require('sh')
local cwd = tostring(pwd())
print('Files in ' .. cwd)
local listing = tostring(ls('.'))
for f in listing:gmatch('[^\n]+') do
  print(f)
end

L'idée est de minimiser les manipulations manuelles lorsqu'on souhaite faire appel à des outils externes et traiter les résultats avec la simplicité de Lua.

Bash ou Lua ? Critères de sélection pratiques

On entend souvent dire sur les forums que reprocher à Bash de ne pas être un langage généraliste est une erreur. Bash est conçu comme un interpréteur de commandes permettant de composer des utilitaires système ; son langage sert à les connecter via des tubes ou la communication interprocessus (IPC).

Si votre travail se déroule principalement en ligne de commande, que vous utilisez quotidiennement des pipes anonymes, des redirections, grep/sed/awk , et que votre logique est moins exigeante qu'une orchestration externe, Bash reste le meilleur outil polyvalent. Il ne rivalise pas avec Lua en tant que langage généraliste ; sa capacité à composer des commandes est inégalée.

Si votre cas nécessite un contrôle de flux élaboré , une transformation de données, des coroutines ou une portabilité stricte (Linux/macOS/Windows) sans dépendre des utilitaires POSIX, Lua offre une expérience plus confortable qui évite la douleur des guillemets et des expansions complexes.

Il est également important de prendre en compte l'écosystème : avec Bash, vous pouvez exploiter tout l'univers des utilitaires (coreutils, binutils, util-linux, etc.). Et si certaines structures de données vous manquent, des outils comme recutils complètent le modèle textuel traditionnel.

Diagnostic des erreurs courantes : le cas de la sortie 127

Dans une discussion populaire, l'exécution d'un script comme `bash bb.sh` a généré le code de sortie 127 après la tentative `lua -e 'print «hha»'` , alors que l'exécution de `source bb.sh` fonctionnait correctement. Sous POSIX, 127 signifie « commande introuvable ».

Si lua est mappé à autre chose (par exemple, dans le fil de discussion, il a été dit que lua est un alias de `lua53` ), lors du lancement d'un nouveau processus avec bash, cet alias ou chemin peut ne pas exister ou peut pointer vers un binaire non présent dans le PATH effectif de ce sous-shell, provoquant l'erreur 127.

Dans les environnements Windows avec Git Bash, un autre facteur entre en jeu : depuis cmd.exe , il est courant de définir des clés de répertoire (par exemple, `doskey lua=lua53 $* `). Si la session Git Bash hérite d'une configuration de l'environnement qui associe `lua` à `lua53` , mais que `lua53` ou son chemin n'est pas présent dans ce sous-shell, vous obtiendrez l'erreur 127. En revanche, lorsque vous exécutez `source` , le shell courant avec son propre chemin/alias est utilisé et la commande fonctionne.

# Comprobar resolución del binario
 type -a lua
 # Sugerencias:
 # 1) Invocar la ruta absoluta: /usr/local/bin/lua o /c/Program Files/lua/lua
 # 2) Desactivar alias: unalias lua; o usa 'command lua' para saltarte funciones/alias
 # 3) Limpia el hash de rutas en bash: hash -r
 # 4) Revisa PATH en el subshell que crea 'bash bb.sh'

Dans ce cas précis, la solution a consisté à supprimer la commande `doskey lua=lua53 $*` de l'invite de commandes. Après quoi, bash lua a retrouvé son fonctionnement normal. Moralité : si vous rencontrez une erreur 127 suspecte , vérifiez les alias, les fonctions du shell et votre variable PATH ; et utilisez `type -a` ou `command -v` pour identifier le binaire qui tente de s'exécuter.

Contexte : Autres langages et outils qui apparaissent dans les sources

Les résultats incluent des descriptions de JavaScript (non seulement pour les navigateurs, mais aussi pour Node.js/Apache CouchDB) et de Python (syntaxe claire et généraliste). Ces langages sont souvent en concurrence pour les rôles de script d'automatisation au sein d'équipes de développement.

Node.js offre un environnement d'exécution d'E/S non bloquant conçu pour le traitement en temps réel, tandis que HTML5 et PHP s'imposent comme des composants historiques du développement web sur certaines pages indexées. Ils ne sont pas des concurrents directs de Bash ou Lua pour l'administration système, mais constituent des alternatives pour l'automatisation multiplateforme.

Les discussions évoquent souvent des utilitaires Python modernes comme uv pour la résolution des dépendances sans avoir à créer de projets lourds, ou des shells alternatifs comme xonsh (basé sur Python), ainsi que des options comme Racket, D en mode script ou OCaml. Conclusion pratique : choisissez l’outil en fonction de la situation spécifique et de l’expérience de votre équipe avec chaque écosystème.

Il est important de rappeler que les plateformes sociales comme Reddit affichent des notifications relatives à la confidentialité et aux cookies avant que vous puissiez consulter le contenu ; cela n’affecte pas la technique, mais cela explique pourquoi les discussions ne se chargent parfois pas si l’on n’accepte pas la notification.

Si vous avez besoin de scripts fonctionnant de manière identique sous Linux, macOS et Windows, avec une logique riche, des tests rapides et une exécution fluide , Lua est un excellent choix. Si vous souhaitez orchestrer des utilitaires POSIX, combiner des outils et réaliser des scripts d'interface avec un minimum de contraintes, Bash reste imbattable. La bonne nouvelle, c'est que ces deux langages ne sont pas incompatibles : combiner Lua (ou Lua + Mako) pour la logique et Bash pour l'interface vous offre le meilleur des deux mondes.