Uppdrag och kontrollstrukturer i Lua

I tidigare tutorials såg vi hur Lua tillåter hantering av både värden och typer på ett dynamiskt sätt, alltid sticker ut för sin enkelhet och mångsidighet när du utför dessa operationer.
Men detta är inte allt Lua erbjuder i form av enkelhet, det stöder konventionellt deklarationer som vi kan hitta på språk som i C eller PascalNär dessa deklarationer inkluderar både uppdrag och kontrollstrukturer kan vi till och med snubbla på några okonventionella sätt som flera uppdrag och lokala deklarationer.
Uppdragen i Lua De är extremt enkla, och de arbetar för att ändra värdet på en variabel vid en viss tid i vårt program, låt oss se ett enkelt exempel med den interaktiva konsolen för Lua, som vi kan ange genom att placera det reserverade ordet lua I terminalen:

Som vi kan se har vi några enkla exempel på tilldelningar, som ändrar värdet på variabler med sammanfogningsoperationer, aritmetik eller helt enkelt genom att skriva värden. Förutom detta, Lua tillåter flera tilldelningar, där en lista med värden tilldelas en lista med variabler, och alltid skiljer dessa listor med kommatecken för korrekt funktion:

Som vi kunde se var1 fick det numeriska värdet och var2 textvärdet, detta enligt den ordning som tilldelningen görs. Om vi ​​är observatörer ser vi hur vi också kan alternera värdena för båda variablerna, något som är praktiskt när vi arbetar med funktioner.
Lua du kan till och med justera antalet värden för antalet variabler som finns, till exempel om listan över värden är mindre än listan över variabler får de extra variablerna värdetypen noll som standard som dess värden, låt oss se ett exempel på denna process:

Som vi kan se får de två första variablerna motsvarande värden och den sista av dessa automatiskt noll som vi förklarar. Det är viktigt att nämna att flera tilldelningar inte alltid är snabbare än enkla uppdrag, men de gör att vi kan hjälpa oss att samla in flera returer från ett funktionsanrop för att nämna några.
Förutom globala variabler, Lua Det stöder lokala variabler som, till skillnad från globala, har ett begränsat omfång, vilket är beroende av blocket där de har deklarerats, låt oss se hur vi deklarerar en lokal variabel:

När vi ser deklarationen av dessa variabler gör vi dem med det reserverade ordet lokalDessa variabler fungerar i blocket där de har deklarerats, till exempel kan vi säga att ett block kan vara en kontrollstruktur eller en funktion, låt oss se följande exempel:

 x = 10 lokal i = 1 medan i <= x gör lokal x = i * 2 utskrift (x) i = i + 1 slut om i> 20 så lokal xx = 20 utskrift (x + 2) annars skriv ut (x) ände skriva ut (x) 

Om vi ​​kör detsamma i vår terminal ser vi hur resultatet kanske inte är vad vi förväntar oss, och det beror på att vi har olika block där vi använder variablerna, låt oss se resultatet:

Även om kontrollen över vårt program kan vara begränsad kan vi använda avgränsarna avsluta För att ange ett block och veta hur långt våra lokala variabler har omfattning, låt oss se ett exempel där vi kan göra detta:

 gör lokal var1 = 16 lokal var2 = var1 + 20 x = 5 y = x + var1 ände - Här slutar omfattningen av var1 och var2 print (x, y) print (var1, var2)

När vi kör det i vår terminal kommer vi att se att variablerna x och y visas utan problem eftersom de är globala, men för var1 och var2 slutar deras omfattning med blocket avsluta, låt oss se:

Vi kan betona att användningen av lokala variabler i våra program är en bra metod, de hjälper oss att inte beröra den globala miljön med onödiga namn, också att tillgången till dessa variabler är mycket snabbare än om vi gjorde det med globala variabler och slutligen dessa variabler försvinner så snart deras omfattning slutar, vilket frigör minnesutrymme, så vi rekommenderar att de används när det är möjligt.
KontrollstrukturerLiksom resten av programmeringsspråken, Lua ger oss en uppsättning kontrollstrukturer som vi kan använda i våra program med hjälp av de välkända om att hantera förhållanden och medan, upprepa Y för för iterativa slingor, där utom upprepa som har den uttryckliga terminatorn fram tills och de andra som slutar med slutet.
Som i de flesta programmeringsspråk deklarationen om kontrollerar ett tillstånd och utför delen av sedan eller delen av annan, där det senare kan vara valfritt, låt oss se en uppsättning av dessa villkor enligt våra program:

 om var1 <0 då var1 = 0 ände om var1 max rader visar sedan () rader = 0 slut

Här har vi tre typer av operationer, den grundläggande med sedan, använder retur för att returnera ett värde enligt villkoret och en lite mer komplett kodbit som kallar en funktion. Förutom detta kan vi skriva om kapslad med annat, vilket sparar oss från att behöva använda flera slutar, låt oss se hur det ser ut:

 om operation == " +" då resultat = a + b elseif operation == " -" då resultat = a - b elseif operation == " *" då resultat = a * b elseif operation == "/" sedan resultat = a / b else fel ("Ogiltig operation") slut

Det är viktigt att notera att detta inte bara är mer optimalt utan också nödvändigt sedan dess Lua har inte typdeklarationerna växla så den här typen av kapslade förhållanden kommer att vara ganska vanliga i våra program.
Som på andra språk, Lua utvärdera först tillståndet för medan, om villkoret är falskt, slutar slingan och annars körs följande kodrader och processen upprepas tills villkoret är falskt, låt oss se ett enkelt exempel för att illustrera detta:

 lokal i = 1 medan var1 [i] skriver ut (var1 [i]) i = i + 1 slut

Detta påstående till skillnad från medan tillåter oss att upprepa koden inuti villkoret tills det är sant, där även denna kod kan köras minst en gång sedan utvärderingen av villkoret görs i slutet, låt oss se ett exempel:

 upprepa rad = os.read () tills rad ~ = "" skriv ut (rad)

Angående iterativa cykler för, Lua har två varianter av det, för numeriska och den generiskt för. Låt oss titta på syntaxen för det numeriska för:

 för var = exp1, exp2, exp3 gör slut

Denna loop kommer att köra något för varje värde av var från exp1 fram tills exp2 använder sig av exp3 som värdet för att öka var eller minska det, om vi inte inkluderar det Lua antar som standard att det går en efter en, låt oss se ett mer detaljerat exempel på dessa cykler:

 för var = 1, f (x) skriv ut (var) slutet för var2 = 10,1, -1 gör utskrift (var2) ände

Som vi ser är applikationen ganska enkel och låter oss implementera användbara iterativa cykler i våra program, låt oss nu se syntaxen för generiskt för:

 för i, var i ipairs (array) skriv ut (var) end

Vad denna cykel gör är att använda den funktion som den ger oss Lua ringa upp ipar, som är en iterator av matriser, där i för varje iteration tar ett index, medan var erhåller det värde som är associerat med det indexet.
Som vi ser uttalandena inom Lua De skiljer sig inte mycket från andra språk, men språket lägger till den extra enkelheten för att ge oss en mycket snabbare inlärning av dess syntax och en mycket mer effektiv användning. Med detta avslutar vi denna handledning, där vi lärde oss uppdragen och kontrollstrukturerna inom Lua, vilket lägger till ytterligare ett lager av kunskap när det gäller detta enkla men kraftfulla språk.