0Pricing
Lua Academy · Leçon

Déclarer des variables en Lua

Comprenez les variables globales et locales ainsi que les conventions de nommage.

Déclarer des variables en Lua est une leçon Lua Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Lua Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Lua Academy comprend 4 leçons au total.

Variables globales et locales

En Lua, les variables sont globales par défaut. Écrire x = 10 sans le mot-clé local crée une variable globale accessible depuis n’importe où. Utiliser local x = 10 limite la variable au bloc actuel et à ses blocs imbriqués.

Privilégiez toujours local pour de meilleures performances et davantage de sécurité. L’accès à une variable locale est plus rapide que l’accès à une variable globale, car les variables globales nécessitent une recherche dans une table de hachage, la table _G.

x = 100          -- global variable
local y = 200    -- local variable

do
  local z = 300  -- block-local
  print(x, y, z) -- 100  200  300
end

print(x, y)      -- 100  200
print(z)         -- nil  (out of scope)

Le mot-clé local

Le mot-clé local déclare une variable dont la portée est limitée au bloc englobant le plus proche : le corps d’une fonction, un bloc do...end, le corps d’une boucle ou un fichier de code. Les variables locales sont créées à la ligne où elles sont déclarées et cessent d’exister à la fin de leur bloc.

Vous pouvez déclarer plusieurs variables locales sur une seule ligne et les initialiser simultanément. Les variables locales non initialisées valent par défaut nil.

local a, b, c = 1, 2, 3
print(a, b, c)    -- 1  2  3

local d, e = 10   -- e is nil
print(d, e)       -- 10  nil

local f           -- nil until assigned
f = 42
print(f)          -- 42

Conventions de nommage des variables

Les identifiants Lua suivent ces règles : ils doivent commencer par une lettre ou un caractère de soulignement, suivi de lettres, de chiffres ou de caractères de soulignement. Lua est sensible à la casse : Value, value et VALUE sont donc trois variables différentes.

Par convention : utilisez camelCase ou snake_case pour les variables ordinaires, UPPER_CASE pour les constantes et préfixez les champs privés des modules par un caractère de soulignement. Évitez les noms d’une seule lettre, sauf pour les compteurs de boucles.

local myVariable = 1     -- camelCase
local my_variable = 2    -- snake_case
local MAX_SIZE = 100     -- constant convention
local _private = "hidden" -- private convention

-- Case sensitivity demo
local lua = "lower"
local Lua = "upper"
print(lua, Lua)  -- lower  upper

La table globale _G

Toutes les variables globales de Lua se trouvent dans une table spéciale appelée _G. Écrire x = 10 équivaut à écrire _G.x = 10. Vous pouvez examiner toutes les variables globales en parcourant _G, ce qui est pratique pour le débogage, mais dangereux dans le code destiné à la production.

Dans Lua 5.2 et les versions ultérieures, _ENV est la véritable table d’environnement et _G est initialisée pour pointer vers elle. Comprendre cela vous permet d’isoler du code dans un environnement contrôlé en remplaçant _ENV.

myGlobal = 42
print(_G.myGlobal)   -- 42

-- Setting via _G is the same as direct assignment
_G.another = "hello"
print(another)        -- hello

-- Counting globals (many built-ins exist)
local count = 0
for k in pairs(_G) do count = count + 1 end
print("Globals:", count)

Affectation multiple

Lua prend en charge l’affectation multiple : vous pouvez affecter plusieurs variables dans une seule instruction. Le membre de droite est d’abord évalué, puis les valeurs sont affectées de gauche à droite. S’il y a plus de variables que de valeurs, les variables supplémentaires reçoivent nil. S’il y a plus de valeurs que de variables, les valeurs supplémentaires sont ignorées.

Cela permet d’échanger très simplement deux variables sans variable temporaire.

-- Swap without temp variable
local a, b = 10, 20
a, b = b, a
print(a, b)   -- 20  10

-- More variables than values
local x, y, z = 1, 2
print(x, y, z)  -- 1  2  nil

-- More values than variables
local p, q = 1, 2, 3  -- 3 is discarded
print(p, q)   -- 1  2

Portée et limites des blocs

Les délimiteurs de blocs de Lua sont : do...end, les corps de fonctions, if/elseif/else...end, while...end, repeat...until et for...end. Chacun crée un nouveau niveau de portée. Les blocs do...end sont utiles simplement pour limiter la portée, sans aucune autre logique.

Une variable locale déclarée dans l’en-tête d’une boucle for a pour portée le corps de la boucle : elle n’est pas accessible à l’extérieur.

for i = 1, 3 do
  local msg = "item " .. i
  print(msg)
end
-- print(i)   -- would be nil, i is gone
-- print(msg) -- would be nil, msg is gone

-- do...end for manual scoping
do
  local temp = expensive_computation or 0
  print(temp)
end
-- temp is nil here

Constantes : la convention local

Lua ne possède pas de mot-clé const intégré. La convention consiste à utiliser des noms UPPER_CASE et local pour signaler qu’une valeur ne doit pas changer. Placer les constantes au début d’un module en tant que variables locales indique également au compilateur JIT que ces valeurs sont stables.

Pour une véritable immuabilité, vous pouvez utiliser une table proxy avec __newindex qui déclenche une erreur en cas de modification — nous verrons cela dans la leçon sur les métatables.

local MAX_RETRIES = 3
local PI = 3.14159265358979
local APP_VERSION = "1.0.0"

-- Use them as read-only by convention
local area = PI * 5 * 5
print(area)           -- 78.539...
print(MAX_RETRIES)    -- 3

Masquage de variables

Le masquage se produit lorsqu’une portée interne déclare une variable locale portant le même nom qu’une variable externe. La déclaration interne crée une variable entièrement nouvelle qui masque la variable externe dans sa portée. La variable externe reste inchangée et redevient visible lorsque la portée interne prend fin.

Le masquage peut prêter à confusion ; privilégiez des noms uniques dans les portées imbriquées, même si ce masquage est parfois intentionnel, par exemple pour réutiliser les noms de variables de boucle dans des boucles imbriquées.

local x = "outer"
do
  local x = "inner"  -- shadows outer x
  print(x)            -- inner
end
print(x)              -- outer (unchanged)

local n = 10
for n = 1, 3 do       -- loop n shadows outer n
  print(n)            -- 1, 2, 3
end
print(n)              -- 10 (outer unchanged)

Éviter la pollution de l’environnement global

Les variables globales créées accidentellement sont un bogue courant en Lua : une faute de frappe dans le nom d’une variable locale crée silencieusement une nouvelle variable globale. Le module strict.lua (souvent inclus dans les projets) détecte les lectures et écritures de variables globales non déclarées en ajoutant une métatable à _G.

Une approche plus simple consiste à toujours utiliser local et à exécuter luac -p ou un analyseur de code tel que luacheck pour détecter les variables globales accidentelles avant l’exécution.

-- Dangerous: typo creates a global silently
local counter = 0
coutner = 5  -- typo! creates global 'coutner'
print(counter)  -- 0 (not 5!)
print(coutner)  -- 5 (the typo global)

-- Fix: always use local keyword
local score = 0
score = 10  -- assigns to existing local
print(score) -- 10

Une affectation à nil supprime les variables globales

Définir une variable globale sur nil la supprime de _G et libère la mémoire. C’est la bonne manière de « supprimer » une variable globale. Pour les variables locales, il suffit de les laisser sortir de leur portée pour obtenir le même effet : le récupérateur de mémoire libère la mémoire.

Soyez prudent lorsque vous transmettez nil dans une affectation multiple : cela peut tronquer la liste d’arguments dans certains contextes, notamment lorsque des appels de fonction se trouvent à droite de l’affectation.

myGlobal = "exists"
print(myGlobal)   -- exists
print(_G.myGlobal ~= nil)  -- true

myGlobal = nil
print(myGlobal)   -- nil
print(_G.myGlobal ~= nil)  -- false
-- The entry is removed from _G

Vérification rapide

Quelle est la portée d’une variable déclarée avec local x = 5 dans le corps d’une boucle for ?

Récapitulatif : déclarer des variables en Lua

Points essentiels de cette leçon :

  • Les variables sont globales par défaut — utilisez toujours local
  • Les variables locales sont plus rapides (aucune recherche dans une table de hachage) et plus sûres
  • Affectation multiple : a, b = b, a échange les valeurs en une seule ligne
  • Toutes les variables globales se trouvent dans _G ; leur affectation à nil les supprime
  • Masquage : une variable local interne masque la variable externe sans la modifier
  • Utilisez UPPER_CASE pour les constantes, par convention

Ensuite : opérateurs arithmétiques, relationnels et logiques.

Questions Fréquemment Posées

La leçon « Déclarer des variables en Lua » est-elle gratuite ?

Oui — le texte complet de « Déclarer des variables en Lua » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Lua Academy, passe à CoddyKit PRO. Le cours Lua Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Déclarer des variables en Lua » ?

Comprenez les variables globales et locales ainsi que les conventions de nommage. Tu pratiques Lua Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Lua Academy ?

Aucune expérience préalable n'est requise. Lua Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Déclarer des variables en Lua » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Lua Academy ?

Oui. Chaque leçon Lua Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Présentation des types de données Lua
  2. Déclarer des variables en Lua
  3. Opérateurs arithmétiques et relationnels
  4. Coercition et conversion de types
← Retour à Lua Academy