Alocări și structuri de control în Lua

În tutorialele din trecut am văzut cum Lua permite manipularea atât a valorilor, cât și a tipurilor într-un mod dinamic, remarcându-se mereu prin simplitatea și versatilitatea sa atunci când se efectuează aceste operații.
Dar asta nu e tot Lua oferă în termeni de simplitate, acceptă în mod convențional declarațiile pe care le putem găsi în limbi ca și în C sau PascalÎn cazul în care aceste declarații includ atribuții și structuri de control deopotrivă, putem chiar să dăm peste unele moduri neconvenționale, cum ar fi mai multe atribuiri și declarații locale.
Sarcinile din Lua Sunt extrem de simple și lucrează pentru a schimba valoarea unei variabile la un anumit moment din cadrul programului nostru, să vedem un exemplu simplu folosind consola interactivă a Lua, pe care îl putem introduce plasând cuvântul rezervat lua În terminal:

După cum putem vedea, avem câteva exemple simple de atribuții, schimbarea valorii variabilelor cu operații de concatenare, aritmetică sau pur și simplu prin scrierea valorilor. În afară de aceasta, Lua permite alocarea multiplă, unde o listă de valori este atribuită unei liste de variabile, separând întotdeauna aceste liste cu virgule pentru o funcționare corectă:

După cum am putut vedea var1 a obținut valoarea numerică și var2 valoarea textului, aceasta în funcție de ordinea în care se face atribuirea. Dacă suntem observatori, vedem cum putem, de asemenea, să alternăm valorile ambelor variabile, lucru care vine la îndemână atunci când lucrăm cu funcții.
Lua puteți chiar să ajustați numărul de valori pentru numărul de variabile prezente, de exemplu, dacă lista de valori este mai mică decât lista de variabile, variabilelor suplimentare li se dă tipul de valoare zero în mod implicit ca valori, să vedem un exemplu al acestui proces:

După cum putem vedea, primele două variabile primesc valorile corespunzătoare, iar ultima dintre acestea primește automat zero după cum explicăm. Este important să menționăm că mai multe sarcini nu sunt întotdeauna mai rapide decât sarcinile simple, dar ne permit să ne ajutăm să colectăm mai multe returnări dintr-un apel funcțional pentru a numi câteva.
În plus față de variabilele globale, Lua Acceptă variabile locale care, spre deosebire de cele globale, au un domeniu limitat, care depinde de blocul în care au fost declarate, să vedem cum declarăm o variabilă locală:

Pe măsură ce vedem declarația acestor variabile, le facem cu cuvântul rezervat localAceste variabile funcționează în blocul în care au fost declarate, de exemplu putem spune că un bloc poate fi o structură de control sau o funcție, să vedem următorul exemplu:

 x = 10 local i = 1 în timp ce i <= x local x = i * 2 print (x) i = i + 1 end if i> 20 then local xx = 20 print (x + 2) else print (x) end print (x) 

Dacă executăm același lucru în terminalul nostru, vom vedea cum rezultatul poate să nu fie ceea ce ne așteptăm și asta pentru că avem blocuri diferite în care folosim variabilele, să vedem rezultatul:

Deși controlul programului nostru poate fi limitat, putem folosi delimitatorii face-sfârșit Pentru a specifica un bloc și a ști cât de departe au variabile locale, să vedem un exemplu în care putem face acest lucru:

 face local var1 = 16 local var2 = var1 + 20 x = 5 y = x + var1 end - Aici se termină sfera var1 și var2 print (x, y) print (var1, var2)

Când îl vom executa în terminalul nostru vom vedea că variabilele x și y sunt afișate fără nicio problemă, deoarece sunt globale, dar pentru var1 și var2 scopul lor se încheie cu blocul face-sfârșit, sa vedem:

Putem sublinia că utilizarea variabilelor locale în programele noastre este o bună practică, acestea ne ajută să nu atingem mediul global cu nume inutile, de asemenea, că accesul la aceste variabile este mult mai rapid decât dacă am face-o cu variabile globale și în cele din urmă acestea variabilele dispar imediat ce sfera lor de aplicare se încheie, eliberând astfel spațiul de memorie, așa că vă recomandăm utilizarea lor ori de câte ori este posibil.
Structuri de controlCa și restul limbajelor de programare, Lua ne oferă un set de structuri de control pe care să le folosim în programele noastre, folosind binecunoscutul dacă să se ocupe de condiții și in timp ce, repeta Da pentru pentru bucle iterative, cu excepția cazului în care repeta care are terminatorul explicit pana cand iar ceilalți se termină cu Sfârșit.
Ca în majoritatea limbajelor de programare, declarația dacă verifică o condiție și execută partea din apoi sau partea din altceva, unde acesta din urmă poate fi opțional, să vedem un set de aceste condiții așa cum se vede în programele noastre:

 if var1 <0 then var1 = 0 end if var1 max lines then show () lines = 0 end

Aici avem trei tipuri de operații, cea de bază cu apoi, folosind return pentru a returna o valoare în funcție de condiție și o bucată de cod puțin mai completă care apelează o funcție. Pe lângă asta putem scrie dacă imbricat folosind elseif, ceea ce ne scutește de a folosi mai multe se termină, să vedem cum arată:

 dacă operație == "+" atunci rezultat = a + b operație elseif == "-" atunci rezultat = a - b operație elseif == "*" atunci rezultat = a * b operație elseif == "/" atunci rezultat = a / b else error („Operațiune nevalidă”) se termină

Este important să rețineți că acest lucru nu este doar mai optim, ci și necesar, deoarece Lua nu are declarațiile de tip intrerupator deci acest tip de condiții imbricate va fi destul de frecvent în programele noastre.
Ca și în alte limbi, Lua evaluează mai întâi starea in timp ce, dacă condiția este falsă, bucla se termină și în caz contrar se execută următoarele linii de cod și procesul se repetă până când condiția este falsă, să vedem un exemplu simplu pentru a ilustra acest lucru:

 local i = 1 în timp ce var1 [i] tipărește (var1 [i]) i = i + 1 capăt

Această afirmație spre deosebire de in timp ce ne permite să repetăm ​​codul în interiorul condiției până când este adevărat, unde chiar și acest cod poate fi executat cel puțin o dată, deoarece evaluarea condiției se face la final, să vedem un exemplu:

 repetă linia = os.read () până la linia ~ = "" print (line)

În ceea ce privește ciclurile iterative pentru, Lua are două variante ale acestuia, pentru numerice si generic pentru. Să ne uităm la sintaxa numerică pentru:

 pentru var = exp1, exp2, exp3 se termină

Această buclă va executa ceva pentru fiecare valoare a var din exp1 pana cand exp2 folosind exp3 ca valoare pentru a crește var sau a o micșora, dacă nu o includem Lua presupune implicit că merge unul câte unul, să vedem un exemplu mai detaliat al acestor cicluri:

 pentru var = 1, f (x) nu tipăriți (var) capăt pentru var2 = 10,1, -1 nu tipăriți (var2) capăt

După cum vedem, aplicația sa este destul de simplă și ne permite să implementăm ciclurile iterative utile în programele noastre, acum să vedem sintaxa pentru generic pentru:

 pentru i, var în ipairs (matrice) face print (var) sfârșit

Ceea ce face acest ciclu este să folosim funcția pe care ne-o oferă Lua apel ipairs, care este un iterator de matrice, unde pentru fiecare iterație i ia un index, în timp ce var obține valoarea asociată cu acel index.
După cum vedem afirmațiile din interior Lua Ele nu diferă mult de alte limbi, însă limbajul adaugă simplitatea suplimentară pentru a ne oferi o învățare mult mai rapidă a sintaxei sale și o utilizare mult mai eficientă. Cu aceasta terminăm acest tutorial, unde am învățat sarcinile și structurile de control din interior Lua, adăugând astfel un alt nivel de cunoștințe atunci când vine vorba de acest limbaj simplu, dar puternic.