Incarichi e strutture di controllo a Lua

Nei tutorial passati abbiamo visto come Lua permette la gestione sia di valori che di tipologie in modo dinamico, distinguendosi sempre per la sua semplicità e versatilità nell'eseguire queste operazioni.
Ma questo non è tutto Lua offre in termini di semplicità, supporta convenzionalmente dichiarazioni che possiamo trovare in lingue come in C o PascalLaddove queste dichiarazioni includono allo stesso modo assegnazioni e strutture di controllo, possiamo persino imbatterci in alcuni modi non convenzionali come assegnazioni multiple e dichiarazioni locali.
I compiti in Lua Sono estremamente semplici, e funzionano per cambiare il valore di una variabile in un determinato momento all'interno del nostro programma, vediamo un semplice esempio utilizzando la console interattiva di Lua, che possiamo inserire inserendo la parola riservata lua Nel terminale:

Come possiamo vedere abbiamo alcuni semplici esempi di assegnazioni, modificando il valore delle variabili con operazioni di concatenazione, aritmetiche o semplicemente scrivendo valori. Oltre a questo, Lua permette l'assegnazione multipla, dove una lista di valori viene assegnata ad una lista di variabili, separando sempre queste liste con virgole per il corretto funzionamento:

Come abbiamo potuto vedere var1 ottenuto il valore numerico e var2 il valore del testo, questo secondo l'ordine in cui viene effettuata l'assegnazione. Se siamo osservatori vediamo come possiamo anche alternare i valori di entrambe le variabili, cosa che torna utile quando si lavora con le funzioni.
Lua puoi anche regolare il numero di valori per il numero di variabili presenti, ad esempio se l'elenco dei valori è inferiore all'elenco delle variabili, alle variabili extra viene assegnato il tipo di valore zero per impostazione predefinita come suoi valori, vediamo un esempio di questo processo:

Come possiamo vedere, le prime due variabili ricevono i loro valori corrispondenti e l'ultima di queste riceve automaticamente zero come spieghiamo. È importante ricordare che le assegnazioni multiple non sono sempre più veloci delle assegnazioni semplici, ma ci consentono di aiutarci a raccogliere più ritorni da una chiamata di funzione per citarne alcune.
Oltre alle variabili globali, Lua Supporta variabili locali che, a differenza di quelle globali, hanno uno scope limitato, che dipende dal blocco in cui sono state dichiarate, vediamo come dichiariamo una variabile locale:

Come vediamo la dichiarazione di queste variabili le facciamo con la parola riservata LocaleQueste variabili funzionano nel blocco in cui sono state dichiarate, ad esempio possiamo dire che un blocco può essere una struttura di controllo o una funzione, vediamo il seguente esempio:

 x = 10 local i = 1 while i <= x do local x = i * 2 print (x) i = i + 1 end if i> 20 then local xx = 20 print (x + 2) else print (x) end stampa (x) 

Se eseguiamo lo stesso nel nostro terminale, vedremo come il risultato potrebbe non essere quello che ci aspettiamo, e questo perché abbiamo diversi blocchi in cui utilizziamo le variabili, vediamo il risultato:

Sebbene il controllo del nostro programma possa essere limitato, possiamo utilizzare i delimitatori fare-fine Per specificare un blocco e sapere fino a che punto le nostre variabili locali hanno portata, vediamo un esempio in cui possiamo farlo:

 do local var1 = 16 local var2 = var1 + 20 x = 5 y = x + var1 end - Qui finisce l'ambito di var1 e var2 print (x, y) print (var1, var2)

Quando lo eseguiamo nel nostro terminale vedremo che le variabili x e y vengono mostrate senza alcun problema perché sono globali, ma per var1 e var2 il loro ambito termina con il blocco fare-fine, vediamo:

Possiamo sottolineare che l'uso di variabili locali nei nostri programmi è una buona pratica, ci aiutano a non toccare l'ambiente globale con nomi non necessari, inoltre l'accesso a queste variabili è molto più veloce che se lo facessimo con variabili globali e infine queste le variabili svaniscono non appena il loro ambito termina liberando spazio di memoria, quindi si consiglia il loro utilizzo quando possibile.
Strutture di controlloCome il resto dei linguaggi di programmazione, Lua ci fornisce una serie di strutture di controllo da utilizzare nei nostri programmi, utilizzando il ben noto Se per gestire le condizioni e mentre, ripetere sì per per i cicli iterativi, dove eccetto ripetere che ha il terminatore esplicito fino a e gli altri che finiscono con fine.
Come nella maggior parte dei linguaggi di programmazione la dichiarazione Se controlla una condizione ed esegue la parte di poi o la parte di altro, dove quest'ultimo può essere facoltativo, vediamo un insieme di queste condizioni come si vede nei nostri programmi:

 se var1 <0 allora var1 = 0 end se var1 max righe allora mostra () righe = 0 end

Qui abbiamo tre tipi di operazioni, quella base con il poi, utilizzando return per restituire un valore in base alla condizione e un pezzo di codice leggermente più completo che chiama una funzione. Oltre a questo possiamo scrivere Se annidato usando altrimenti, che ci evita di dover utilizzare più finisce, vediamo come si presenta:

 if operazione == "+" then risultato = a + b operazione elseif == "-" allora risultato = a - b operazione elseif == "*" then risultato = a * b operazione elseif == "/" allora risultato = a /b else errore ("Operazione non valida") end

È importante notare che questo non è solo più ottimale ma anche necessario poiché Lua non ha le dichiarazioni di tipo interruttore quindi questo tipo di condizioni annidate sarà abbastanza comune nei nostri programmi.
Come in altre lingue, Lua valutare prima la condizione del mentre, se la condizione è falsa il ciclo termina e in caso contrario vengono eseguite le seguenti righe di codice e il processo viene ripetuto finché la condizione non è falsa, vediamo un semplice esempio per illustrare ciò:

 local i = 1 mentre var1 [i] do print (var1 [i]) i = i + 1 end

Questa affermazione a differenza del mentre ci permette di ripetere il codice all'interno della condizione fino a quando non è vero, dove anche questo codice può essere eseguito almeno una volta poiché la valutazione della condizione viene fatta alla fine, vediamo un esempio:

 ripeti riga = os.read () fino a riga ~ = "" print (line)

Per quanto riguarda i cicli iterativi per, Lua ne ha due varianti, la per numerico e il generico per. Diamo un'occhiata alla sintassi del numerico per:

 for var = exp1, exp2, exp3 do end

Questo ciclo eseguirà qualcosa per ogni valore di varia a partire dal esp1 fino a esp2 usando esp3 come valore da aumentare var o diminuirlo, se non lo includiamo Lua presuppone di default che vada uno per uno, vediamo un esempio più dettagliato di questi cicli:

 for var = 1, f (x) stampa (var) end per var2 = 10,1, -1 stampa (var2) end

Come vediamo la sua applicazione è abbastanza semplice e ci permette di implementare gli utili cicli iterativi nei nostri programmi, ora vediamo la sintassi per il generico per:

 for i, var in ipairs (array) do print (var) end

Quello che fa questo ciclo è usare la funzione che ci dà Lua chiamata ipairs, che è un iteratore di array, dove per ogni iterazione i prende un indice, mentre var ottiene il valore associato a quell'indice.
Come vediamo le dichiarazioni all'interno Lua Non differiscono molto dagli altri linguaggi, tuttavia il linguaggio aggiunge quella semplicità in più per darci un apprendimento molto più rapido della sua sintassi e un uso molto più efficace. Con questo finiamo questo tutorial, dove abbiamo imparato le assegnazioni e le strutture di controllo all'interno Lua, aggiungendo così un altro livello di conoscenza quando si tratta di questo linguaggio semplice ma potente.