Dies ist jedoch nicht alles, was Lua in Bezug auf die Einfachheit anbietet. Es unterstützt konventionelle Aussagen, die wir in Sprachen wie C oder Pascal finden können , wo diese Anweisungen Zuweisungen und Kontrollstrukturen gleichermaßen enthalten, und wir können uns sogar einige einfallen lassen unkonventionelle Methoden wie Mehrfachzuweisungen und lokale Anweisungen.

Aufträge

Die Zuweisungen in Lua sind sehr einfach und dienen dazu, den Wert einer Variablen zu einem bestimmten Zeitpunkt in unserem Programm zu ändern. Sehen wir uns ein einfaches Beispiel mit der interaktiven Lua- Konsole an, die wir mit dem in reservierten Wort lua eingeben können Terminal:

Wie wir sehen können, haben wir einige einfache Beispiele für Zuweisungen, die den Wert von Variablen durch Verkettungsoperationen, Arithmetik oder einfaches Schreiben von Werten ändern. Darüber hinaus ermöglicht Lua die Mehrfachzuweisung, bei der einer Variablenliste eine Werteliste zugewiesen wird, wobei diese Listen für den ordnungsgemäßen Betrieb immer durch Kommas getrennt werden:

Wie wir sehen konnten, erhielt var1 den numerischen Wert und var2 den Textwert, und zwar in der Reihenfolge, in der die Zuweisung erfolgt. Wenn wir Beobachter sind, sehen wir, wie wir auch die Werte beider Variablen abwechseln können, was uns bei der Arbeit mit Funktionen sehr nützlich ist.

Lua kann sogar die Anzahl der Werte für die Anzahl der vorhandenen Variablen anpassen. Wenn beispielsweise die Liste der Werte kleiner als die Liste der Variablen ist, erhalten die zusätzlichen Variablen den Standardwerttyp Null als ihre Werte. Schauen wir uns ein Beispiel dafür an prozess:

Wie wir sehen, erhalten die ersten beiden Variablen ihre entsprechenden Werte und die letzte von diesen erhält automatisch null, wie wir erklärt haben. Es ist wichtig zu erwähnen, dass Mehrfachzuweisungen nicht immer schneller sind als einfache Zuweisungen, aber diese ermöglichen es uns, mehrere Rückgaben von einem Funktionsaufruf zu sammeln, indem wir eine erwähnen.

Lokale Variablen und Blöcke

Zusätzlich zu den globalen Variablen unterstützt Lua lokale Variablen, die, anders als die globalen, einen begrenzten Gültigkeitsbereich haben, der von dem Block abhängt, in dem sie deklariert wurden. Sehen wir uns an, wie wir eine lokale Variable deklarieren:

Da wir die Deklaration dieser Variablen sehen, die wir mit dem lokal reservierten Wort durchführen, arbeiten diese Variablen in dem Block, in dem sie deklariert wurden. Wir können beispielsweise sagen, dass ein Block eine Kontrollstruktur oder eine Funktion sein kann. Schauen wir uns das folgende Beispiel an:

 x = 10 local i = 1 während ich <= x tue lokales x = i * 2 print (x) i = i + 1 ende wenn ich> 20 dann lokal x x = 20 print (x + 2) sonst print (x) ende print (x) 

Wenn wir dasselbe in unserem Terminal ausführen, werden wir sehen, dass das Ergebnis möglicherweise nicht unseren Erwartungen entspricht. Dies liegt daran, dass wir verschiedene Blöcke haben, in denen wir die Variablen verwenden. Sehen wir uns das Ergebnis an:

Obwohl die Kontrolle über unser Programm begrenzt sein mag, können wir die Begrenzer für das Ende verwenden , um einen Block anzugeben und zu wissen, wie weit unsere lokalen Variablen reichen. Sehen wir uns ein Beispiel an, wo wir dies tun können:

 zu tun local var1 = 16 local var2 = var1 + 20 x = 5 y = x + var1 ende - Hier endet der Gültigkeitsbereich von var1 und var2 print (x, y) print (var1, var2) 

Wenn wir es in unserem Terminal ausführen, werden wir sehen, dass die Variablen x und y problemlos angezeigt werden, da sie global sind, aber für var1 und var2 endet der Gültigkeitsbereich mit dem do-end- Block.

Wir können betonen, dass die Verwendung lokaler Variablen in unseren Programmen eine gute Praxis ist. Diese helfen uns, die globale Umgebung nicht mit unnötigen Namen zu berühren. Außerdem ist der Zugriff auf diese Variablen viel schneller als bei globalen Variablen und schließlich Diese Variablen verschwinden, sobald ihr Gültigkeitsbereich endet, wodurch Speicherplatz frei wird. Wir empfehlen daher, sie nach Möglichkeit zu verwenden.

Wenn, dann und sonst

Wie in den meisten Programmiersprachen überprüft die if- Anweisung eine Bedingung und führt den Teil des then oder den Teil des else aus , wobei letzterer optional sein kann. Sehen wir uns die folgenden Bedingungen in unseren Programmen an:

 Wenn var1 <0, dann ist var1 = 0 Wenn var1 <var2, wird var1 zurückgegeben, andernfalls wird var2 end zurückgegeben wenn linien> maxlineas dann show () Zeilen = 0 ende 

Hier haben wir drei Arten von Operationen, die grundlegende mit der Funktion then , bei der mithilfe der Rückgabe ein Wert entsprechend der Bedingung und ein etwas vollständigerer Code zurückgegeben wird, der eine Funktion aufruft. Darüber hinaus können wir schreiben, wenn es mit elseif verschachtelt ist , was vermeidet, dass mehrere Enden verwendet werden müssen. Schauen wir uns an, wie es aussieht:

 wenn operation == "+" dann Ergebnis = a + b elseif operation == "-" then Ergebnis = a - b elseif operation == "*" dann Ergebnis = a * b elseif operation == "/" then Ergebnis = a / b sonst Fehler ("Operation macht ungültig") ende 

Es ist wichtig zu beachten, dass dies nicht nur optimaler, sondern auch notwendig ist, da Lua keine Switch- Typdeklarationen hat, sodass diese Art von verschachtelten Bedingungen in unseren Programmen durchaus üblich ist.

While-Schleife

Wie in anderen Sprachen wertet Lua zunächst den Zustand der while-Anweisung aus . Wenn der Zustand false ist, endet die Schleife. Andernfalls werden die folgenden Codezeilen ausgeführt und der Vorgang wiederholt, bis der Zustand false ist. Sehen wir uns ein einfaches Beispiel für an veranschaulichen dies:

 local i = 1 während var1 [i] tun print (var1 [i]) i = i + 1 ende 

Schleife wiederholen

Diese Anweisung erlaubt es uns im Gegensatz zur while- Anweisung, den Code innerhalb der Bedingung so lange zu wiederholen, bis er wahr ist, wobei selbst dieser Code mindestens einmal ausgeführt werden kann, da die Auswertung der Bedingung am Ende erfolgt. Sehen wir uns ein Beispiel an:

 wiederhole line = os.read () bis linea ~ = "" print (Zeile) 

Für numerisch und für generisch

In Bezug auf die iterativen Zyklen für hat Lua zwei Varianten, die numerische für und die generische für . Sehen wir uns die Syntax der numerischen Form an:

 für var = exp1, exp2, exp3 mache <wir machen etwas> ende 

In diesem Zyklus wird für jeden Wert von var von exp1 bis exp2 etwas ausgeführt , wobei exp3 als Wert zum Erhöhen oder Verringern von var verwendet wird. Wenn wir ihn nicht einschließen, geht Lua standardmäßig davon aus, dass er nacheinander ausgeführt wird. Sehen wir uns ein ausführlicheres Beispiel dieser Zyklen an:

 für var = 1 gibt f (x) das (var) ende aus für var2 = 10,1, -1 schreibe das Ende (var2) 

Da die Anwendung recht einfach ist und es uns ermöglicht, die nützlichen iterativen Zyklen in unseren Programmen zu implementieren, sehen wir uns nun die Syntax für das Generische an :

 Für i gibt var in ipairs (array) das Ende (var) aus 

In diesem Zyklus wird die von Lua zur Verfügung gestellte Funktion ipairs verwendet , bei der es sich um einen Iterator von Fixes handelt, bei dem für jede Iteration ein Index erstellt wird, während var den diesem Index zugeordneten Wert erhält.

Wie wir sehen, unterscheiden sich die Aussagen in Lua nicht wesentlich von anderen Sprachen, die Sprache fügt jedoch diese zusätzliche Einfachheit hinzu, um uns ein viel schnelleres Erlernen der Syntax und eine viel effektivere Verwendung zu ermöglichen. Damit haben wir dieses Tutorial abgeschlossen, in dem wir die Zuordnungen und Kontrollstrukturen in Lua kennengelernt und so eine weitere Wissensschicht in Bezug auf diese einfache, aber mächtige Sprache hinzugefügt haben.