Tutorial su Lua

Lua è un lin­guag­gio di scripting svi­lup­pa­to in Brasile all’inizio degli anni ‘90. Il codice sorgente di un programma Lua viene tradotto in byte code ed eseguito dall’in­ter­pre­te Lua. L’in­ter­pre­te stesso è scritto in C, il che aiuta i programmi Lua a ottenere pre­sta­zio­ni elevate. Inoltre, l’API C consente al codice Lua di essere in­cor­po­ra­to in programmi C/C++. Lua è un lin­guag­gio mul­ti­pa­ra­dig­ma adatto a scrivere codice im­pe­ra­ti­vo, fun­zio­na­le e orientato agli oggetti.

Il prin­ci­pa­le punto di forza di Lua è la facile in­te­gra­zio­ne in altri sistemi e linguaggi. Lua si è così affermato come “glue language” ed è uti­liz­za­to in molti motori grafici di vi­deo­gio­chi. Il lin­guag­gio può essere uti­liz­za­to anche per con­trol­la­re server web come Apache e nginx. Lua viene spesso usato come lin­guag­gio di pro­gram­ma­zio­ne Internet autonomo tramite l’in­ter­fac­cia CGI. Inoltre, questo lin­guag­gio viene uti­liz­za­to anche per la pro­gram­ma­zio­ne di app mobili.

L’in­ter­pre­te Lua consiste in un singolo file binario di­spo­ni­bi­le sulla riga di comando dopo aver dato il comando “lua”. Questo viene me­mo­riz­za­to nel sistema e potrebbe dover essere incluso nel percorso. Lua offre anche librerie che con­sen­to­no l’in­cor­po­ra­men­to del codice nei programmi C/C++.

Per Mac e Linux, l’ideale è l’in­stal­la­zio­ne con il gestore di pacchetti “Homebrew”. Se avete in­stal­la­to Homebrew sul vostro sistema, è meglio se uti­liz­za­te il seguente codice sulla riga di comando per in­stal­la­re Lua:

Per in­stal­la­re Lua su un sistema Windows potete uti­liz­za­re LuaDist Installer.

Come spesso accade con i linguaggi di scripting, è possibile eseguire l’in­ter­pre­te Lua in modo in­te­rat­ti­vo. In modalità in­te­rat­ti­va, l’in­ter­pre­te riceve il codice Lua sulla riga di comando e lo esegue riga per riga. I valori generati vengono vi­sua­liz­za­ti di­ret­ta­men­te sulla riga di comando. Come utente, è possibile dunque con­trol­la­re e mo­di­fi­ca­re i valori delle variabili. Questo approccio è quindi par­ti­co­lar­men­te adatto per la pro­to­ti­pa­zio­ne rapida. Per avviare l’in­ter­pre­te Lua in modalità in­te­rat­ti­va, bisogna eseguire il seguente comando sulla riga di comando:

Invece di inserire il codice Lua pezzo per pezzo sulla riga di comando, potete istruire l’in­ter­pre­te Lua a eseguire un file di codice sorgente Lua completo. Per fare ciò, bisogna prima di tutto creare un file Lua e passare il nome del file all’in­ter­pre­te per l’ese­cu­zio­ne. L’in­ter­pre­te legge riga per riga il codice sorgente contenuto nel file e lo esegue.

Sui sistemi operativi Linux / UNIX / macOS, abbiamo anche la pos­si­bi­li­tà di rendere di­ret­ta­men­te ese­gui­bi­le un file di codice sorgente Lua. Per fare ciò, dobbiamo inserire un co­sid­det­to “shebang” come prima riga del file Lua:

Os­ser­via­mo come lo shebang contenga la posizione del file binario Lua, nel nostro caso “#!/usr/local/bin/lua”. La posizione di ar­chi­via­zio­ne sul sistema locale potrebbe essere diversa. In questo caso, potete de­ter­mi­na­re la posizione del file binario Lua. A tale scopo, uti­liz­za­te il comando “which” sulla riga di comando:

Dopo aver eseguito lo shebang di uno script Lua, dovete con­tras­se­gna­re il file come ese­gui­bi­le dall’utente. Quindi uti­liz­za­te il seguente codice sulla riga di comando:

Suc­ces­si­va­men­te eseguite lo script Lua nella directory corrente:

Lua è un lin­guag­gio mul­ti­pa­ra­dig­ma; lo stile di base è im­pe­ra­ti­vo e fun­zio­na­le. Il lin­guag­gio è com­ple­ta­men­te dinamico, ovvero non viene fatta alcuna di­stin­zio­ne tra “compile time” e “runtime”. Lua si affida alla gestione dinamica della memoria, senza eccezioni: la di­men­sio­ne di un oggetto in memoria può cambiare durante il runtime. Un “Garbage Collector” (GC) libera lo spazio in memoria che non è più ne­ces­sa­rio in modo che il pro­gram­ma­to­re non debba pre­oc­cu­par­se­ne.

I commenti sono una parte es­sen­zia­le di qualsiasi lin­guag­gio di pro­gram­ma­zio­ne. Fra gli altri, sono uti­liz­za­ti per i seguenti scopi:

• Fare bozze delle com­po­nen­ti del codice
• Do­cu­men­ta­re le ca­rat­te­ri­sti­che del codice
• Attivare / di­sat­ti­va­re le righe di codice

Un commento a riga singola in Lua inizia con un doppio trattino (--) e arriva alla fine della riga:

In com­bi­na­zio­ne con le doppie parentesi quadre “[[“ e “]]” è possibile scrivere anche commenti su più righe:

Come la maggior parte degli altri linguaggi di scripting, Lua è un lin­guag­gio tipizzato di­na­mi­ca­men­te. I tipi non ap­par­ten­go­no a variabili, ma a valori. Ogni valore ha un tipo specifico, sia esso un numero, una stringa di caratteri, un valore logico, ecc. Nel complesso, Lua ha una quantità gestibile di tipi, che sono riassunti qui di seguito:

Lua conosce la sintassi letterale per i valori di tutti i tipi ad eccezione di “thread” e “userdata”. Per de­ter­mi­na­re il tipo di un valore, usiamo la funzione “type ()”. Ciò re­sti­tui­sce il nome del tipo come stringa. Di seguito alcuni esempi:

Un’espres­sio­ne (“ex­pres­sion”) viene valutata dall’in­ter­pre­te e re­sti­tui­sce un valore. Le espres­sio­ni combinano letterali, operatori, variabili e chiamate di funzione. Le espres­sio­ni possono essere fa­col­ta­ti­va­men­te rag­grup­pa­te fra parentesi “()”. Essendo un lin­guag­gio dinamico, Lua determina au­to­ma­ti­ca­men­te il tipo di valore re­sti­tui­to. Di seguito alcuni esempi di espres­sio­ni:

Una variabile è un nome per un valore in memoria. Come nella maggior parte dei linguaggi di pro­gram­ma­zio­ne, un nome in Lua inizia con una lettera o un trattino basso (_), seguito da lettere ag­giun­ti­ve, trattini bassi o numeri. Viene fatta una netta di­stin­zio­ne tra maiuscole e minuscole. Le seguenti parole riservate non possono essere uti­liz­za­te come nomi da sole:

“And”, “end”, “in”, “repeat”, “break”, “false”, “local”, “return”, “do”, “for”, “nil”, “then”, “else”, “function”, “not”, “true”, “elseif”, “if”, “or”, “until”, “while”

Tuttavia, queste parole riservate possono apparire come parte di un nome senza problemi:

Un valore viene assegnato a una variabile uti­liz­zan­do l’operatore di as­se­gna­zio­ne (=), che non deve essere confuso con l’operatore di ugua­glian­za logica (==). Come al solito, durante l’as­se­gna­zio­ne viene fatta una di­stin­zio­ne tra “L-value” e “R-value”: la variabile deve essere a sinistra dell’operatore di as­se­gna­zio­ne, cioè è il valore L. A questo viene assegnato il valore valutato del valore R a destra:

Un operatore crea un nuovo valore da uno o più operandi. Si parla di un operatore unario (una cifra) o binario (due cifre). Un operatore collega operandi di un certo tipo e re­sti­tui­sce un valore di un certo tipo. Diamo un’occhiata ai diversi operatori in Lua.

Gli operatori arit­me­ti­ci operano sui numeri e re­sti­tui­sco­no un numero:

Gli operatori re­la­zio­na­li sono tutti binari e testano la relazione tra due operandi. Re­sti­tui­sco­no un valore di verità:

Gli operatori logici combinano valori di verità e re­sti­tui­sco­no un nuovo valore di verità:

Oltre a quanto riportato sopra, ci sono due operatori speciali in Lua che servono per con­ca­te­na­re stringhe e de­ter­mi­na­re la potenza di un valore composto, come una tabella o una stringa:

Lua non ha operatori di as­se­gna­zio­ne composti come “+=“ e “-=“, che sono comuni in molti linguaggi di scripting. Per aumentare e diminuire le variabili, l’ope­ra­zio­ne viene scritta espli­ci­ta­men­te:

Il concetto di “ambito di validità” è centrale in qualsiasi lin­guag­gio di pro­gram­ma­zio­ne. Una variabile esiste solo entro un certo ambito di validità. Come in Ja­va­Script, le variabili in Lua sono globali per im­po­sta­zio­ne pre­de­fi­ni­ta. Tuttavia, l’uso continuo di variabili globali è noto come “anti-pattern” e dovrebbe essere evitato. In Lua, la parola chiave “local” può essere d’aiuto. Infatti, limita l’ambito di una variabile al blocco cir­co­stan­te, pa­ra­go­na­bi­le alla di­chia­ra­zio­ne tramite “let” in Ja­va­Script.

I corpi delle funzioni e i cicli aprono un nuovo ambito di validità in Lua. Lua utilizza anche il concetto di blocco esplicito. Un blocco definisce un nuovo ambito di validità per il codice che si trova fra le parole chiave “do” e “end”. Ciò cor­ri­spon­de alle parentesi di apertura e chiusura “{“ e ”}” in Java/C/C++. Il seguente esempio di codice mostra come sono correlati blocchi, ambiti e variabili:

Lua utilizza le classiche strutture di controllo che troviamo anche in altri linguaggi di pro­gram­ma­zio­ne. Ciò include di­ra­ma­zio­ni e cicli. Di seguito un esempio delle direttive “if”, “then”, “else”, “elseif” di Lua:

Oltre al classico ciclo “while”, Lua riconosce anche la sua con­tro­par­te “repeat”-”until”. Questa istru­zio­ne esiste anche in Ruby e richiede l’in­ver­sio­ne della con­di­zio­ne applicata. Ciò significa che “while” con la con­di­zio­ne “numero </= limit” cor­ri­spon­de a “repeat”-”until” con la con­di­zio­ne “numero > limit”. At­ten­zio­ne all’istru­zio­ne “repeat”! In­di­pen­den­te­men­te dalla con­di­zio­ne, il ciclo viene eseguito almeno una volta. Qui un esempio:

Come la maggior parte dei linguaggi di pro­gram­ma­zio­ne im­pe­ra­ti­vi, Lua ha anche un’istru­zio­ne “for” oltre al ciclo “while”. Possono essere uti­liz­za­te due forme: una variante simile a C con una variabile di ciclo e una variante con un iteratore. Con­si­de­ria­mo prima l’uso dell’istru­zio­ne “for” con una variabile di ciclo:

Al contrario di quello che si potrebbe pensare, la variabile definita nel ciclo “for” è locale, non globale, senza dover essere espli­ci­ta­men­te di­chia­ra­ta come “locale” ed è qui che Lua dif­fe­ri­sce da Ja­va­Script in modo positivo. In Ja­va­Script, una variabile di ciclo senza “let” o “var” viene di­chia­ra­ta au­to­ma­ti­ca­men­te come globale, il che può portare a gravi errori.

Diamo adesso un’occhiata al ciclo “for” di Lua con l’iteratore. In linea di principio, l’approccio è simile a quello di Python: invece di in­cre­men­ta­re una variabile di ciclo e usarla come indice in una lista, iteriamo di­ret­ta­men­te sugli elementi della lista. La funzione “ipairs()” viene spesso uti­liz­za­ta per generare l’iteratore. Ecco un esempio:

Come in C/C++, Java e Ja­va­Script, le funzioni sono definite con la parola chiave “function”. Come spesso accade, i parametri delle funzioni seguono i nomi delle funzioni tra parentesi. La par­ti­co­la­ri­tà di Lua è che le parentesi possono essere omesse quando si richiama una funzione che ha esat­ta­men­te un letterale come argomento. Una funzione di Lua non deve ne­ces­sa­ria­men­te re­sti­tui­re un valore. Secondo la de­fi­ni­zio­ne, in assenza di un valore si tratta di una “procedura”:

Se si vuole re­sti­tui­re un valore da una funzione, come al solito si può uti­liz­za­re la parola chiave “return”. Ciò termina l’ese­cu­zio­ne della funzione e re­sti­tui­sce il valore spe­ci­fi­ca­to. Nel seguente esempio di codice un numero viene mol­ti­pli­ca­to al quadrato:

Come in Python e Ja­va­Script, una funzione in Lua può accettare un numero variabile di argomenti. Gli argomenti vengono salvati nel costrutto speciale “(...)”. Per accedere agli argomenti, è spesso utile rias­su­mer­li in una lista con l’espres­sio­ne “{...}”. In al­ter­na­ti­va, può essere uti­liz­za­ta la funzione “select ()”, che estrae un argomento sotto l’indice spe­ci­fi­ca­to. Il numero di argomenti viene de­ter­mi­na­to con l’espres­sio­ne “# {...}”.

Oltre al numero variabile di argomenti, Lua consente anche di re­sti­tui­re più valori con l’istru­zio­ne “return”. Funziona in modo simile a Python, ma senza un tipo “tupla” esplicito. Come in Python, è comune assegnare i valori di ritorno a più variabili quando si chiama una funzione. Ecco un esempio:

Se uno dei valori re­sti­tui­ti non è ne­ces­sa­rio, la con­ven­zio­ne comune consiste nell’uti­liz­za­re il trattino basso (_) come se­gna­po­sto, come mostrato nell’esempio seguente:

In Lua, le funzioni sono “first-class citizens”. Ciò significa che possono essere associate a variabili e quindi trasmesse anche come argomenti ad altre funzioni. Una funzione può inoltre servire come valore di ritorno di una funzione. Lua consente una pro­gram­ma­zio­ne fun­zio­na­le, mostrata qui usando l’esempio della famosa funzione “map ()”:

La ri­cor­si­vi­tà viene spesso uti­liz­za­ta nella pro­gram­ma­zio­ne fun­zio­na­le: una funzione chiama se stessa più e più volte con argomenti mo­di­fi­ca­ti. Bisogna fare par­ti­co­la­re at­ten­zio­ne con Lua. Le funzioni ri­chia­ma­te in modo ricorsivo do­vreb­be­ro essere di­chia­ra­te espli­ci­ta­men­te come “local”.