Uzdevumi un kontroles struktūras Lua

Iepriekšējās apmācībās mēs redzējām, kā Lua ļauj dinamiski apstrādāt gan vērtības, gan veidus, vienmēr izceļoties ar vienkāršību un daudzpusību, veicot šīs darbības.
Bet tas vēl nav viss Lua piedāvā vienkāršības ziņā, tas parasti atbalsta deklarācijas, kuras mēs varam atrast tādās valodās kā C vai PaskālsJa šajās deklarācijās ir iekļauti gan uzdevumi, gan kontroles struktūras, mēs pat varam paklupt pie dažiem netradicionāliem veidiem, piemēram, vairākiem uzdevumiem un vietējām deklarācijām.
Uzdevumi Lua Tie ir ārkārtīgi vienkārši, un tie darbojas, lai mainītu mainīgā vērtību noteiktā laikā mūsu programmā. Apskatīsim vienkāršu piemēru, izmantojot interaktīvo konsole Lua, kuru mēs varam ievadīt, ievietojot rezervēto vārdu lua Terminālī:

Kā redzam, mums ir daži vienkārši uzdevumu piemēri, mainot mainīgo lielumu ar salikšanas operācijām, aritmētiski vai vienkārši ierakstot vērtības. Bez tam, Lua ļauj piešķirt vairākus piešķīrumus, kur mainīgo sarakstam tiek piešķirts vērtību saraksts, vienmēr atdalot šos sarakstus ar komatiem pareizai darbībai:

Kā mēs varējām redzēt var1 ieguva skaitlisko vērtību un var2 teksta vērtību, tas saskaņā ar uzdevuma veikšanas secību. Ja mēs esam novērotāji, mēs redzam, kā mēs varam arī mainīt abu mainīgo vērtības, kas ir noderīgi, strādājot ar funkcijām.
Lua jūs pat varat pielāgot vērtību skaitu esošo mainīgo skaitam, piemēram, ja vērtību saraksts ir mazāks par mainīgo sarakstu, papildu mainīgajiem tiek piešķirts vērtību tips nulle pēc noklusējuma kā vērtības, aplūkosim šī procesa piemēru:

Kā redzam, pirmie divi mainīgie saņem atbilstošās vērtības, bet pēdējie no tiem saņem automātiski nulle kā mēs skaidrojam. Ir svarīgi pieminēt, ka vairāki uzdevumi ne vienmēr ir ātrāki par vienkāršiem uzdevumiem, taču tie ļauj mums palīdzēt apkopot vairākas atdeves no funkcijas izsaukuma, lai nosauktu dažus.
Papildus globālajiem mainīgajiem, Lua Tas atbalsta vietējos mainīgos, kuriem atšķirībā no globālajiem ir ierobežota darbības joma, kas ir atkarīga no bloka, kurā tie ir deklarēti, paskatīsimies, kā mēs deklarējam vietējo mainīgo:

Kā mēs redzam šo mainīgo deklarāciju, mēs tos darām ar rezervēto vārdu vietējaisŠie mainīgie darbojas blokā, kurā tie ir deklarēti, piemēram, mēs varam teikt, ka bloks var būt vadības struktūra vai funkcija, apskatīsim šādu piemēru:

 x = 10 vietējais i = 1, bet i <= x do local x = i * 2 print (x) i = i + 1 end, ja i> 20, tad vietējais xx = 20 print (x + 2) else print (x) end drukāt (x) 

Ja mēs savā terminālī izpildīsim to pašu, mēs redzēsim, kā rezultāts var nebūt tas, ko mēs gaidām, un tas ir tāpēc, ka mums ir dažādi bloki, kuros mēs izmantojam mainīgos, redzēsim rezultātu:

Lai gan mūsu programmas kontrole var būt ierobežota, mēs varam izmantot norobežotājus do-end Lai norādītu bloku un zinātu, cik lielā mērā mūsu lokālajiem mainīgajiem ir darbības joma, apskatīsim piemēru, kā to izdarīt:

 do local var1 = 16 local var2 = var1 + 20 x = 5 y = x + var1 end - Šeit beidzas var1 un var2 drukas darbības joma print (x, y) print (var1, var2)

Izpildot to savā terminālī, mēs redzēsim, ka mainīgie x un y tiek parādīti bez problēmām, jo ​​tie ir globāli, bet var1 un var2 to darbības joma beidzas ar bloku do-end, paskatīsimies:

Mēs varam uzsvērt, ka vietējo mainīgo izmantošana mūsu programmās ir laba prakse, tie palīdz mums nepieskarties globālajai videi ar nevajadzīgiem nosaukumiem, kā arī ka piekļuve šiem mainīgajiem ir daudz ātrāka nekā tad, ja mēs to darītu ar globālajiem mainīgajiem un visbeidzot mainīgie pazūd, tiklīdz to darbības joma beidzas, tādējādi atbrīvojot vietu atmiņā, tāpēc mēs iesakām tos izmantot, kad vien iespējams.
Kontroles struktūrasTāpat kā pārējās programmēšanas valodas, Lua nodrošina mums kontroles struktūru kopumu, ko mēs varam izmantot mūsu programmās, izmantojot labi zināmo ja lai tiktu galā ar apstākļiem un kamēr, atkārtot Y priekš atkārtotām cilpām, izņemot atkārtot kam ir skaidrs terminators līdz un pārējie beidzas ar beigas.
Tāpat kā lielākajā daļā programmēšanas valodu, deklarācija ja pārbauda nosacījumu un izpilda daļu tad vai tā daļa citādi, ja pēdējais var būt neobligāts, aplūkosim šo nosacījumu kopumu, kas redzams mūsu programmās:

 ja var1 <0, tad var1 = 0 beigas, ja var1 max rindas, tad rāda () līnijas = 0 beigas

Šeit mums ir trīs veidu darbības, pamata ar tad, izmantojot atgriešanos, lai atgrieztu vērtību atbilstoši nosacījumam un nedaudz pilnīgāku koda daļu, kas izsauc funkciju. Turklāt mēs varam rakstīt ja ligzdots, izmantojot elseif, kas pasargā mūs no vairāku lietojuma beidzas, redzēsim, kā tas izskatās:

 ja operācija == " +", tad rezultāts = a + b elseif darbība == " -", tad rezultāts = a - b elseif darbība == " *", tad rezultāts = a * b citsif operācija == "/", tad rezultāts = a / b else kļūda ("Nederīga darbība") beigas

Ir svarīgi atzīmēt, ka tas ir ne tikai optimālāk, bet arī nepieciešams kopš tā laika Lua nav tipa deklarāciju slēdzis tāpēc šāda veida ligzdotie nosacījumi mūsu programmās būs diezgan izplatīti.
Tāpat kā citās valodās, Lua vispirms novērtējiet stāvokli kamēr, ja nosacījums ir nepatiess, cikls beidzas un citādi tiek izpildītas šādas koda rindas un process tiek atkārtots, līdz nosacījums ir nepatiess, aplūkosim vienkāršu piemēru, lai to ilustrētu:

 vietējais i = 1, bet var1 [i] drukā (var1 [i]) i = i + 1 beigas

Šis paziņojums atšķirībā no kamēr ļauj mums atkārtot kodu nosacījuma iekšienē, līdz tas ir patiess, kur pat šo kodu var izpildīt vismaz vienu reizi, jo nosacījuma novērtēšana tiek veikta beigās, apskatīsim piemēru:

 atkārtot rindu = os.read () līdz rindai ~ = "" print (line)

Attiecībā uz iteratīvajiem cikliem priekš, Lua ir divi tā varianti, par ciparu un vispārīgs priekš. Apskatīsim ciparu sintaksi:

 var = exp1, exp2, exp3 do end

Šī cilpa izpildīs kaut ko katrai var no exp1 līdz exp2 izmantojot exp3 kā vērtību, lai palielinātu vai samazinātu to, ja to neiekļaujam Lua pēc noklusējuma pieņem, ka tas notiek pa vienam, apskatīsim detalizētāku šo ciklu piemēru:

 var = 1, f (x) drukāt (var) beigas var2 = 10,1, -1 drukāt (var2) beigas

Tā kā mēs redzam, ka tā pielietojums ir diezgan vienkāršs un ļauj mums savās programmās ieviest noderīgos iteratīvos ciklus, tagad apskatīsim sintaksi vispārīgs priekš:

 i, var ipairs (masīvs) drukā (var) beigās

Šis cikls izmanto funkciju, ko tā mums dod Lua zvanīt ipairs, kas ir masīvu iterators, kur katrai iterācijai i ņem indeksu, bet var iegūst ar šo indeksu saistīto vērtību.
Kā mēs redzam paziņojumus iekšpusē Lua Tās daudz neatšķiras no citām valodām, tomēr valoda piebilst, ka papildu vienkāršība ļauj mums daudz ātrāk apgūt tās sintaksi un daudz efektīvāk izmantot. Ar to mēs pabeidzam šo apmācību, kurā mēs uzzinājām uzdevumus un kontroles struktūras Lua, tādējādi pievienojot vēl vienu zināšanu slāni, kad runa ir par šo vienkāršo, bet spēcīgo valodu.