0Pricing
Lua Academy · Lezione

Dichiarare variabili in Lua

Comprenda la differenza tra variabili globali e locali e le convenzioni di denominazione.

Dichiarare variabili in Lua è una lezione Lua Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Lua Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Lua Academy include 4 lezioni in totale.

Variabili globali e locali

In Lua, le variabili sono globali per impostazione predefinita. Scrivere x = 10 senza la parola chiave local crea una variabile globale accessibile ovunque. Usare local x = 10 limita la variabile al blocco corrente e ai relativi blocchi annidati.

È consigliabile preferire sempre local per motivi di prestazioni e sicurezza. L’accesso a una variabile locale è più rapido di quello a una variabile globale, perché le variabili globali richiedono una ricerca in una tabella hash nella tabella _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)

La parola chiave local

La parola chiave local dichiara una variabile con ambito limitato al blocco più vicino che la contiene: il corpo di una funzione, un blocco do...end, il corpo di un ciclo o un chunk di file. Le variabili locali vengono create alla riga in cui sono dichiarate e cessano di esistere alla fine del relativo blocco.

È possibile dichiarare più variabili locali su una sola riga e inizializzarle simultaneamente. Le variabili locali non inizializzate assumono il valore predefinito 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

Convenzioni per i nomi delle variabili

Gli identificatori Lua seguono queste regole: devono iniziare con una lettera o un underscore, seguito da lettere, cifre o underscore. Lua distingue tra maiuscole e minuscole, quindi Value, value e VALUE sono tre variabili diverse.

Per convenzione, usare camelCase o snake_case per le variabili comuni, UPPER_CASE per le costanti e anteporre un underscore ai campi privati dei moduli. Evitare i nomi composti da una sola lettera, tranne che per i contatori dei cicli.

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 tabella globale _G

Tutte le variabili globali in Lua risiedono in una tabella speciale chiamata _G. Scrivere x = 10 equivale a scrivere _G.x = 10. È possibile esaminare tutte le variabili globali iterando su _G, una tecnica utile per il debugging ma rischiosa nel codice di produzione.

In Lua 5.2+, _ENV è la tabella dell’ambiente effettiva e _G viene inizializzata in modo da puntare a essa. Comprendere questo meccanismo consente di isolare il codice sostituendo _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)

Assegnazione multipla

Lua supporta l’assegnazione multipla: è possibile assegnare valori a più variabili in un’unica istruzione. Il lato destro viene valutato per primo, quindi i valori vengono assegnati da sinistra verso destra. Se le variabili sono più numerose dei valori, quelle aggiuntive ricevono nil. Se i valori sono più numerosi delle variabili, quelli aggiuntivi vengono scartati.

Questo rende semplicissimo scambiare due variabili senza usare una variabile temporanea.

-- 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

Ambito e confini dei blocchi

I delimitatori dei blocchi Lua sono: do...end, i corpi delle funzioni, if/elseif/else...end, while...end, repeat...until e for...end. Ognuno crea un nuovo livello di ambito. I blocchi do...end sono utili esclusivamente per limitare l’ambito, senza aggiungere altra logica.

Una variabile locale dichiarata nell’intestazione di un ciclo for ha ambito limitato al corpo del ciclo e non è accessibile all’esterno.

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

Costanti: la convenzione local

Lua non dispone di una parola chiave const integrata. La convenzione consiste nell’usare nomi UPPER_CASE e local per indicare che un valore non dovrebbe cambiare. Posizionare le costanti all’inizio di un modulo come variabili locali fornisce inoltre al compilatore JIT un’indicazione della stabilità di questi valori.

Per ottenere una vera immutabilità, è possibile usare una tabella proxy con __newindex che genera un errore in caso di modifica; questo argomento sarà trattato nella lezione sulle metatabelle.

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

Shadowing delle variabili

Lo shadowing si verifica quando un ambito interno dichiara una variabile locale con lo stesso nome di una variabile esterna. La dichiarazione interna crea una variabile completamente nuova, che nasconde quella esterna all’interno del proprio ambito. La variabile esterna non cambia e torna visibile quando termina l’ambito interno.

Lo shadowing può creare confusione; è preferibile usare nomi diversi negli ambiti annidati, anche se talvolta è intenzionale, ad esempio per riutilizzare i nomi delle variabili di ciclo in cicli annidati.

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)

Evitare l’inquinamento globale

Le variabili globali accidentali sono un errore comune in Lua: un errore di battitura nel nome di una variabile locale crea silenziosamente una nuova variabile globale. Il modulo strict.lua (comunemente incluso nei progetti) rileva le letture e le scritture di variabili globali non dichiarate aggiungendo una metatabella a _G.

Un approccio più semplice consiste nell’usare sempre local ed eseguire luac -p o un linter come luacheck per rilevare le variabili globali accidentali prima dell’esecuzione.

-- 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

L’assegnazione di nil elimina le variabili globali

Impostare una variabile globale su nil la rimuove da _G, liberando memoria. Questo è il modo corretto per "eliminare" una variabile globale. Per le variabili locali, è sufficiente lasciarle uscire dall’ambito: il garbage collector recupererà la memoria.

Prestare attenzione quando si passa nil in un’assegnazione multipla: in alcuni contesti può troncare l’elenco degli argomenti, in particolare quando il lato destro contiene chiamate di funzione.

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

Verifica rapida

Qual è l’ambito di una variabile dichiarata con local x = 5 all’interno del corpo di un ciclo for?

Riepilogo: dichiarare variabili in Lua

Punti chiave della lezione:

  • Le variabili sono globali per impostazione predefinita: usare sempre local
  • Le variabili locali sono più rapide (non richiedono una ricerca hash) e più sicure
  • Assegnazione multipla: a, b = b, a scambia i valori in una sola riga
  • Tutte le variabili globali risiedono in _G; impostarle su nil le elimina
  • Shadowing: una variabile local interna nasconde quella esterna senza modificarla
  • Per convenzione, usare UPPER_CASE per le costanti

Successivamente: operatori aritmetici, relazionali e logici.

Domande Frequenti

La lezione «Dichiarare variabili in Lua» è gratuita?

Sì — il testo completo di «Dichiarare variabili in Lua» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Lua Academy, passa a CoddyKit PRO. Il corso Lua Academy include 4 lezioni in totale.

Cosa imparerò in «Dichiarare variabili in Lua»?

Comprenda la differenza tra variabili globali e locali e le convenzioni di denominazione. Eserciti Lua Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Lua Academy?

Non è richiesta alcuna esperienza precedente. Lua Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Dichiarare variabili in Lua»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Lua Academy?

Sì. Ogni lezione Lua Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Panoramica dei tipi di dati Lua
  2. Dichiarare variabili in Lua
  3. Operatori aritmetici e relazionali
  4. Coercizione e conversione dei tipi
← Torna a Lua Academy