Variabili e Blocchi locali

Inoltre le variabili globali, Lua supporta variabili locali. Creiamo variabili locali con il locale di dichiarazione:

j = 10 - variabile globale
i locali = 1 - variabile locale

A differenza delle variabili globali, variabili locali hanno il loro ambito di applicazione limitato al blocco in cui sono dichiarate. Un blocco è il corpo di una struttura di controllo, il corpo di una funzione, o un pezzo (il file o stringa con il codice in cui viene dichiarata la variabile).

x = 10
i locali = 1 - locale al pezzo

mentre i <= x fare
x locali = i * 2 - locale per il corpo mentre
stampa (x) -> 2, 4, 6, 8,
i = i + 1
fine

se i> 20 poi
x locale - locale al "poi" corpo
x = 20
stampa (x + 2)
altro
stampa (x) -> 10 (quello globale)
fine

stampa (x) -> 10 (quello globale)

Attenzione che questo esempio non funzionerà come previsto se si entra in modalità interattiva. La seconda linea, i locali = 1, è un pezzo completo di per sé. Non appena si entra in questa linea, Lua gestisce e avvia un nuovo pezzo nella riga successiva. Da allora, il locale di dichiarazione è già fuori del campo di applicazione. Per eseguire tali esempi in modalità interattiva, si dovrebbe racchiudere tutto il codice in un do blocco.
È buono stile di programmazione per utilizzare le variabili locali quando possibile. Le variabili locali consentono di evitare di ingombrare l'ambiente globale con i nomi inutili. Inoltre, l'accesso alle variabili locali è più veloce rispetto a quelle globali.

Lua gestisce le dichiarazioni delle variabili locali come dichiarazioni. Come tale, è possibile scrivere dichiarazioni locali ovunque si può scrivere una dichiarazione. Il campo di applicazione ha inizio dopo la dichiarazione e va fino alla fine del blocco. La dichiarazione può includere un incarico iniziale, che funziona allo stesso modo come un compito tradizionale: i valori aggiuntivi vengono gettati via; variabili aggiuntive diventano nulle. Come un caso specifico, se la dichiarazione non ha assegnazione iniziale, inizializza tutte le sue variabili con nil.

locali a, b = 1, 10
se un <b allora
stampa (a) -> 1
locale a - `= nil 'è implicita
stampa (a) -> nil
fine - conclude il blocco iniziato alle `poi '
stampa (a, b) -> 1 10
Un linguaggio comune in Lua è

foo locale = foo

Questo codice crea una variabile locale, pippo, e lo inizializza con il valore della variabile globale foo. Questo linguaggio è utile quando il pezzo ha bisogno di preservare il valore originale di foo anche se poi qualche altra funzione cambia il valore del globale foo; Consente inoltre di velocizzare l'accesso a pippo.
Perché molte lingue ti costringono a dichiarare tutte le variabili locali all'inizio di un blocco (o di una procedura), alcune persone pensano che sia una cattiva pratica di utilizzare le dichiarazioni nel bel mezzo di un blocco. Al contrario: Dichiarando una variabile solo quando ne hai bisogno, raramente bisogno di dichiararlo, senza un valore iniziale (e quindi raramente dimenticate di inizializzare). Inoltre, si accorcia la portata della variabile, che aumenta la leggibilità.

Siamo in grado di delimitare un blocco in modo esplicito, bracketing con le parole chiave do - end. Queste fare blocchi possono essere utile quando è necessario un controllo più preciso sulla portata di una o più variabili locali:

fare
a2 locale = 2 * a
d locale = sqrt (b ^ 2-4 * a * c)
x1 = (-b + d) / a2
x2 = (-b - d) / a2
fine - ambito di applicazione 'a2' e `d 'finisce qui
stampa (x1, x2)