Meilleures extensions de formatage Lua pour VS Code

Lua n’impose aucun standard de style. Le parseur du langage accepte toute indentation valide, tout espacement d’opérateurs et toute disposition de blocs - ce qui signifie que chaque développeur retombe sur ses propres habitudes. Dans un projet solo, c’est acceptable. Dans une base de code partagée, un mod de jeu ou un dépôt de scripts d’équipe, le formatage incohérent crée du bruit dans chaque diff, ralentit la revue de code et complique le débogage plus que nécessaire.

Le coût d’un style Lua incohérent

Quand deux personnes écrivent du Lua différemment - l’une utilise une indentation de quatre espaces, l’autre des tabulations ; l’une espace les opérateurs, l’autre pas - chaque commit contient des changements de formatage mêlés aux changements de logique. Les relecteurs passent du temps à lire des diffs de style au lieu de diffs de logique. Les conflits de fusion explosent. Un formateur résout cela en normalisant chaque fichier au même style à l’enregistrement, rendant les diffs propres et relisibles.

• Indentation cohérente - les blocs `do`/`end`, `if`/`end`, `function`/`end` s’indenteront toujours de la même façon
• Espacement uniforme - les espaces autour de `=`, `+`, `-`, `..` et des autres opérateurs sont appliqués de façon cohérente
• Discipline des lignes vides - les lignes vides superflues entre fonctions et dans les boucles sont normalisées automatiquement
• Gestion lisible des chaînes - les longues concaténations et les chaînes multilignes sont disposées de façon prévisible
• Application à l’échelle de l’équipe - un `.luarc.json` ou `stylua.toml` partagé dans le gestionnaire de versions garantit que tous suivent les mêmes règles

Le Marketplace VS Code propose plusieurs extensions Lua, mais seules une poignée sont activement maintenues et offrent un formatage fiable. Voici les trois à connaître en 2026, par ordre de recommandation.

1. Lua Language Server (sumneko.lua) - recommandé

Le Lua Language Server, publié sous l’identifiant `sumneko.lua` sur le Marketplace VS Code, est l’outil de développement Lua le plus complet disponible pour VS Code. Il installe une implémentation complète du Language Server Protocol (LSP) fournissant diagnostics, inférence de types, aller à la définition, documentation au survol, recherche de références dans tout l’espace de travail et un formateur intégré - le tout dans une seule extension.

• Éditeur : sumneko (Tang Liu)
• ID Marketplace : `sumneko.lua`
• Installations actives : 1M+ (en 2026)
• Versions de Lua prises en charge : 5.1, 5.2, 5.3, 5.4, LuaJIT
• Formateur : Intégré, configuré via `.luarc.json`
• Format à l’enregistrement : Pris en charge nativement
• Idéal pour : La plupart des flux Lua - scripts de jeu, outils autonomes, systèmes embarqués

2. StyLua (jq-steuersoftware.stylua) - alternative à style assumé

StyLua est un formateur de code Lua au style assumé, écrit en Rust et inspiré de Prettier. L’extension VS Code encapsule le binaire StyLua et l’intègre comme formateur de documents. Contrairement au Lua Language Server, StyLua est un outil de formatage seul - il ne fournit ni diagnostics, ni documentation au survol, ni complétion. Ce qu’il apporte, c’est un style déterministe sans débat : vous acceptez le style et vous vous y tenez, comme Prettier le fait pour JavaScript.

• Éditeur : jq-steuersoftware
• ID Marketplace : `jq-steuersoftware.stylua`
• Versions de Lua prises en charge : 5.1, 5.2, 5.3, 5.4, LuaJIT, Luau (Roblox)
• Fichier de config : `stylua.toml` (facultatif - très bien avec les valeurs par défaut)
• Format à l’enregistrement : Pris en charge nativement
• Idéal pour : Nouveaux projets, équipes voulant un formatage sans config à la Prettier, développement Luau Roblox

3. LuaFormatter (Koihik.vscode-lua-format) - option historique configurable

LuaFormatter est une extension plus ancienne qui encapsule l’outil en ligne de commande `lua-format`. Elle offre une configuration étendue - vous pouvez régler finement la largeur d’indentation, la longueur maximale de ligne, l’espacement des opérateurs, l’indentation de continuation et bien d’autres règles individuellement. Ce niveau de contrôle est utile lors de la migration d’une base de code existante qui possède déjà une convention de style que le formateur doit respecter. Cependant, son développement a ralenti depuis l’arrivée de StyLua, et le binaire `lua-format` exige une étape d’installation séparée sur certaines plateformes.

• Éditeur : Koihik
• ID Marketplace : `Koihik.vscode-lua-format`
• Fichier de config : `.lua-format` (format YAML)
• Idéal pour : Bases de code existantes avec des exigences de style complexes, contrôle granulaire règle par règle
• Réserve : Exige le binaire `lua-format` installé séparément sur Linux/Mac

Installer le Lua Language Server prend moins de deux minutes. Voici le chemin de configuration complet, d’une installation fraîche de VS Code jusqu’au format à l’enregistrement opérationnel.

{
  "Lua.runtime.version": "Lua 5.4",
  "Lua.diagnostics.globals": ["myGlobal", "anotherGlobal"],
  "Lua.format.enable": true,
  "Lua.format.defaultConfig": {
    "indent_style": "space",
    "indent_size": "4",
    "max_line_length": "120",
    "trailing_table_separator": "smart"
  }
}

{
  "editor.formatOnSave": true,
  "[lua]": {
    "editor.defaultFormatter": "sumneko.lua"
  }
}

Le format à l’enregistrement est le réglage individuel le plus impactant pour le développement Lua dans VS Code. Une fois actif, vous ne déclenchez plus jamais le formateur manuellement - il s’exécute à chaque Ctrl+S. Voici comment le configurer correctement pour différents scénarios d’équipe.

Paramètres utilisateur vs paramètres d’espace de travail

VS Code a deux niveaux de paramètres : au niveau utilisateur (s’applique à tous les projets) et au niveau espace de travail (uniquement au projet courant). Pour le formatage, le niveau espace de travail est presque toujours le bon choix - il garantit que chaque contributeur du projet utilise le même formateur, indépendamment de ses préférences personnelles. Les paramètres d’espace de travail vivent dans `.vscode/settings.json` à la racine du projet et doivent être commités.

Format à l’enregistrement avec StyLua

L’extension VS Code de StyLua utilise le même mécanisme de format à l’enregistrement. Définissez le formateur par défaut sur `jq-steuersoftware.stylua` dans vos paramètres d’espace de travail. StyLua lit un fichier de config `stylua.toml` s’il existe - c’est là que vous réglez column_width, indent_type, indent_width et quote_style. Sans `stylua.toml`, StyLua applique ses règles par défaut (indentation de deux espaces, lignes de 120 caractères, guillemets doubles).

column_width = 120
line_endings = "Unix"
indent_type = "Spaces"
indent_width = 4
quote_style = "AutoPreferDouble"
call_parentheses = "Always"

Exclure des fichiers du formatage

Certains fichiers Lua ne doivent pas être reformatés - bibliothèques vendor, code généré ou scripts minifiés. Dans StyLua, ajoutez un fichier `.styluaignore` (même syntaxe que `.gitignore`) pour exclure des chemins. Dans le Lua Language Server, vous pouvez circonscrire le formateur à des répertoires spécifiques via le réglage `Lua.workspace.ignoreDir` dans `.luarc.json`.

Les deux formateurs Lua les plus discutés sont LuaFormatter et StyLua. Leurs philosophies de formatage diffèrent fondamentalement, et le bon choix dépend du contexte de votre projet. Voici une comparaison directe.

Si vous démarrez un nouveau projet, choisissez StyLua et commitez la config. Si vous héritez d’une base de code au style établi, configurez LuaFormatter pour le respecter. Ne mélangez jamais les deux formateurs sur la même base de code.

Lua Language Server vs StyLua : peuvent-ils cohabiter ?

Le Lua Language Server et StyLua servent des buts premiers différents - Lua LS est un language server complet pour diagnostics et intellisense, StyLua n’est qu’un formateur. Ils peuvent cohabiter dans la même configuration VS Code : installez Lua LS pour les diagnostics et l’intelligence du code, puis définissez StyLua comme formateur par défaut pour le formatage des documents. Cette combinaison donne le meilleur des deux outils. Configurez-la dans .vscode/settings.json en fixant le defaultFormatter de [lua] à jq-steuersoftware.stylua tout en gardant Lua LS installé pour ses fonctionnalités LSP.

Le formateur intégré de Lua LS : quand suffit-il ?

Pour la plupart des développeurs, le formateur intégré du Lua Language Server suffit et supprime le besoin d’installer une seconde extension. Il gère toutes les tâches de formatage standard et s’intègre proprement avec `.luarc.json`. La raison principale d’ajouter StyLua par-dessus est que votre équipe veuille une application de style plus stricte (p. ex. imposer un style de guillemets ou des conventions de parenthèses d’appel) que le formateur de Lua LS ne prend pas encore en charge.

Les extensions VS Code sont la bonne solution pour le développement au quotidien. Mais il existe des scénarios où vous devez formater du code Lua sans rien installer du tout - et c’est là qu’un outil basé navigateur comble proprement le vide.

Quand vous ne pouvez pas installer d’extensions

• Machines partagées ou verrouillées - postes d’entreprise, ordinateurs de labo ou environnements CI où l’installation d’extensions VS Code est impossible
• Nettoyage ponctuel - un collègue vous envoie un extrait Lua à relire et vous voulez le formater sans changer de contexte
• Revue de code sans environnement de dev - relire une pull request sur une machine où votre installation Lua complète n’est pas configurée
• Vérifications d’intégration - vérifier qu’un fichier est bien formaté avant commit sans attendre l’installation de toute la chaîne d’outils
• Inspection de code minifié - vous avez une sortie du minifieur Lua et voulez la reformater pour la lisibilité

Le Formateur Lua d’Aback Tools gère tous ces cas. Collez votre code Lua dans l’éditeur et le formateur applique une indentation cohérente, normalise l’espacement des opérateurs et nettoie les lignes vides dans votre navigateur - sans inscription, sans installation, sans aucune donnée quittant votre appareil.

Outils Lua en ligne complémentaires

Le formatage n’est qu’une étape d’un flux complet de qualité de code Lua. Plusieurs autres outils navigateur couvrent les tâches adjacentes dont vous aurez régulièrement besoin en plus du formatage :

• **Lua Beautifier** - se concentre sur l’amélioration de la présentation visuelle d’un code syntaxiquement correct mais difficile à lire
• **Validateur de syntaxe Lua** - vérifie le code pour les erreurs au niveau du parseur avec diagnostics par ligne avant exécution
• **Minifieur Lua** - retire commentaires, espaces et lignes vides pour le déploiement en production afin de réduire la taille des scripts
• **Obfuscateur Lua** - renomme les variables et encode les chaînes pour protéger les scripts de jeu de la rétro-ingénierie occasionnelle
• **Assistant de désobfuscation Lua** - améliore la lisibilité des scripts obfusqués pour les flux de débogage et d’analyse

Un formateur gère les blancs, mais la bonne qualité de code Lua va plus loin. Ces pratiques accompagnent votre formateur pour garder les bases de code Lua cohérentes, lisibles et maintenables à toute échelle.

Commitez la config de votre formateur

Un `.luarc.json` pour Lua LS, un `stylua.toml` pour StyLua ou un `.lua-format` pour LuaFormatter doivent vivre à la racine du projet et être commités dans votre dépôt. Cela garantit que chaque contributeur - et chaque exécution CI - utilise des règles de formatage identiques. Sans config committée, chaque développeur retombe sur les réglages de sa propre extension et la divergence de formatage revient insidieusement.

Ajoutez un contrôle de formatage en CI

Le format à l’enregistrement dans VS Code n’aide que ceux qui l’utilisent avec l’extension installée. Un contrôle CI attrape ce qui glisse - contributeurs sur d’autres éditeurs, fichiers rapidement patchés ou code Lua généré. Le drapeau `--check` de StyLua sort avec un code non nul si un fichier n’est pas correctement formaté, ce qui facilite l’échec d’un job GitHub Actions ou GitLab CI sur des violations de style.

Séparez les commits de formatage des commits de logique

Si vous introduisez un formateur pour la première fois dans une base de code existante, exécutez le formateur sur tous les fichiers dans un unique commit dédié sans autre changement. Étiquetez-le clairement (p. ex. `chore: apply lua formatter to all files`). Cela enferme le bruit de formatage dans un seul commit pour que tous les commits suivants ne contiennent que des changements de logique - et `git blame` reste utile sur chaque ligne.

Utilisez une nomenclature cohérente pour les variables locales

Les formateurs ne renomment pas les variables - c’est votre responsabilité. La communauté Lua suit majoritairement `snake_case` pour les variables et fonctions et `PascalCase` pour les tables de niveau module et les constructions de type classe. Accordez-vous sur une convention avec votre équipe et documentez-la dans le `CONTRIBUTING.md` de votre projet. Si vous travaillez avec Roblox Luau, le guide de style Roblox spécifie `PascalCase` pour les instances et services et `camelCase` pour les variables locales - gardez la distinction à l’esprit avant d’appliquer aveuglément les conventions de la communauté Lua.