Opdrachten en controlestructuren in Lua

In eerdere tutorials hebben we gezien hoe Lua maakt het mogelijk om zowel waarden als typen op een dynamische manier te verwerken, waarbij het altijd opvalt door zijn eenvoud en veelzijdigheid bij het uitvoeren van deze bewerkingen.
Maar dit is niet alles Lua biedt in termen van eenvoud, het ondersteunt conventioneel verklaringen die we kunnen vinden in talen als in C of PascalWaar deze verklaringen zowel toewijzingen als controlestructuren omvatten, kunnen we zelfs enkele onconventionele manieren tegenkomen, zoals meerdere toewijzingen en lokale verklaringen.
De opdrachten in Lua Ze zijn uiterst eenvoudig, en ze werken om de waarde van een variabele op een bepaald moment in ons programma te wijzigen, laten we een eenvoudig voorbeeld bekijken met behulp van de interactieve console van Lua, die we kunnen invoeren door het gereserveerde woord te plaatsen lua In de terminal:

Zoals we kunnen zien, hebben we enkele eenvoudige voorbeelden van toewijzingen, het wijzigen van de waarde van variabelen met aaneenschakelingsbewerkingen, rekenkunde of gewoon door waarden te schrijven. Naast dit, Lua staat meervoudige toewijzing toe, waarbij een lijst met waarden wordt toegewezen aan een lijst met variabelen, waarbij deze lijsten altijd worden gescheiden met komma's voor een juiste werking:

Zoals we konden zien var1 kreeg de numerieke waarde en var2 de tekstwaarde, dit volgens de volgorde waarin de opdracht is gemaakt. Als we waarnemers zijn, zien we hoe we ook de waarden van beide variabelen kunnen afwisselen, iets wat goed van pas komt als we met functies werken.
Lua je kunt zelfs het aantal waarden aanpassen voor het aantal aanwezige variabelen, bijvoorbeeld als de lijst met waarden kleiner is dan de lijst met variabelen, krijgen de extra variabelen het waardetype nul standaard als zijn waarden, laten we een voorbeeld van dit proces bekijken:

Zoals we kunnen zien, ontvangen de eerste twee variabelen hun overeenkomstige waarden en de laatste hiervan automatisch nul zoals we uitleggen. Het is belangrijk om te vermelden dat meerdere toewijzingen niet altijd sneller zijn dan eenvoudige toewijzingen, maar ze stellen ons in staat om ons te helpen meerdere resultaten van een functieaanroep te verzamelen om er maar een paar te noemen.
Naast globale variabelen, Lua Het ondersteunt lokale variabelen die, in tegenstelling tot globale, een beperkte reikwijdte hebben, die afhankelijk is van het blok waarin ze zijn gedeclareerd, laten we eens kijken hoe we een lokale variabele declareren:

Als we de declaratie van deze variabelen zien, doen we ze met het gereserveerde woord lokaalDeze variabelen werken in het blok waarin ze zijn gedeclareerd, we kunnen bijvoorbeeld zeggen dat een blok een besturingsstructuur of een functie kan zijn, laten we het volgende voorbeeld bekijken:

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

Als we hetzelfde in onze terminal uitvoeren, zullen we zien hoe het resultaat misschien niet is wat we verwachten, en dit komt omdat we verschillende blokken hebben waarin we de variabelen gebruiken, laten we het resultaat bekijken:

Hoewel de controle over ons programma beperkt kan zijn, kunnen we de scheidingstekens gebruiken einde maken Om een ​​blok te specificeren en te weten hoe ver onze lokale variabelen bereik hebben, laten we een voorbeeld bekijken waarin we dit kunnen doen:

 do local var1 = 16 local var2 = var1 + 20 x = 5 y = x + var1 end - Hier eindigt het bereik van var1 en var2 print (x, y) print (var1, var2)

Wanneer we het in onze terminal uitvoeren, zullen we zien dat de variabelen x en y zonder enig probleem worden weergegeven omdat ze globaal zijn, maar voor var1 en var2 eindigt hun bereik met het blok einde maken, laten we kijken:

We kunnen benadrukken dat het gebruik van lokale variabelen in onze programma's een goede gewoonte is, ze helpen ons om de globale omgeving niet te raken met onnodige namen, ook dat de toegang tot deze variabelen veel sneller is dan wanneer we het zouden doen met globale variabelen en tenslotte deze variabelen verdwijnen zodra hun bereik eindigt, waardoor geheugenruimte wordt vrijgemaakt, dus we raden het gebruik ervan waar mogelijk aan.
Controle structurenNet als de rest van de programmeertalen, Lua biedt ons een reeks controlestructuren die we in onze programma's kunnen gebruiken, met behulp van de bekende indien om te gaan met omstandigheden en terwijl, herhalen Y voor voor iteratieve lussen, waarbij behalve herhalen die de expliciete terminator heeft tot en de anderen eindigen met einde.
Zoals in de meeste programmeertalen de verklaring indien controleert een voorwaarde en voert het deel van de . uit dan of het deel van anders, waar de laatste optioneel kan zijn, laten we een reeks van deze voorwaarden bekijken zoals te zien in onze programma's:

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

Hier hebben we drie soorten bewerkingen, de basis met de dan, met return om een ​​waarde te retourneren volgens de voorwaarde en een iets completer stuk code dat een functie aanroept. Daarnaast kunnen we schrijven indien genest met behulp van anders, waardoor we niet meerdere moeten gebruiken loopt af, laten we eens kijken hoe het eruit ziet:

 if operatie == "+" dan resultaat = a + b elseif operatie == "-" dan resultaat = a - b elseif operatie == "*" dan resultaat = a * b elseif operatie == "/" dan resultaat = a / b else fout ("Ongeldige bewerking") end

Het is belangrijk op te merken dat dit niet alleen meer optimaal is, maar ook noodzakelijk omdat Lua heeft niet de typeverklaringen schakelaar dus dit soort geneste voorwaarden zal heel gewoon zijn in onze programma's.
Net als in andere talen, Lua evalueer eerst de toestand van de terwijl, als de voorwaarde onwaar is, eindigt de lus en anders worden de volgende coderegels uitgevoerd en wordt het proces herhaald totdat de voorwaarde onwaar is, laten we een eenvoudig voorbeeld bekijken om dit te illustreren:

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

Deze verklaring in tegenstelling tot de terwijl stelt ons in staat om de code binnen de voorwaarde te herhalen totdat deze waar is, waarbij zelfs deze code minstens één keer kan worden uitgevoerd sinds de evaluatie van de voorwaarde aan het einde is gedaan, laten we een voorbeeld bekijken:

 herhaal regel = os.read () tot regel ~ = "" print (regel)

Met betrekking tot iteratieve cycli voor, Lua heeft er twee varianten van, de voor numeriek en de generiek voor. Laten we eens kijken naar de syntaxis van het numerieke voor:

 voor var = exp1, exp2, exp3 eindigen

Deze lus zal iets uitvoeren voor elke waarde van var van exp1 tot exp2 gebruik makend van exp3 als de waarde om var te verhogen of te verlagen, als we het niet opnemen Lua gaat er standaard van uit dat het één voor één gaat, laten we een meer gedetailleerd voorbeeld van deze cycli bekijken:

 voor var = 1, f (x) do print (var) end voor var2 = 10,1, -1 do print (var2) end

Zoals we zien, is de toepassing ervan vrij eenvoudig en kunnen we de nuttige iteratieve cycli in onze programma's implementeren. Laten we nu eens kijken naar de syntaxis voor de generiek voor:

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

Wat deze cyclus doet, is de functie gebruiken die het ons geeft Lua telefoongesprek ipairs, wat een iterator van arrays is, waarbij i voor elke iteratie een index neemt, terwijl var de waarde verkrijgt die bij die index hoort.
Zoals we de verklaringen binnen zien, Lua Ze verschillen niet veel van andere talen, maar de taal voegt die extra eenvoud toe om ons een veel snellere kennis van de syntaxis en een veel effectiever gebruik te geven. Hiermee sluiten we deze tutorial af, waar we de opdrachten en besturingsstructuren binnen hebben geleerd Lua, waardoor een nieuwe kennislaag wordt toegevoegd als het gaat om deze eenvoudige maar krachtige taal.