Aufgaben und Kontrollstrukturen in Lua

In früheren Tutorials haben wir gesehen, wie Lua ermöglicht die dynamische Handhabung sowohl von Werten als auch von Typen und zeichnet sich bei der Durchführung dieser Operationen immer durch Einfachheit und Vielseitigkeit aus.
Aber das ist nicht alles Lua bietet in Bezug auf die Einfachheit herkömmlicherweise Deklarationen, die wir in Sprachen wie in . finden können C oder PascalWenn diese Deklarationen gleichermaßen Zuweisungen und Kontrollstrukturen enthalten, können wir sogar auf unkonventionelle Wege wie Mehrfachzuweisungen und lokale Deklarationen stoßen.
Die Aufgaben in Lua Sie sind extrem einfach und funktionieren, um den Wert einer Variablen zu einem bestimmten Zeitpunkt in unserem Programm zu ändern. Sehen wir uns ein einfaches Beispiel mit der interaktiven Konsole von . an Lua, die wir eingeben können, indem wir das reservierte Wort platzieren lua Im Terminal:

Wie wir sehen, haben wir einige einfache Beispiele für Zuweisungen, die den Wert von Variablen mit Verkettungsoperationen, Arithmetik oder einfach durch das Schreiben von Werten ändern. Abgesehen davon, Lua ermöglicht eine Mehrfachzuweisung, bei der einer Liste von Variablen eine Liste von Werten zugewiesen wird, wobei diese Listen für eine korrekte Operation immer durch Kommas getrennt werden:

Wie wir sehen konnten var1 habe den Zahlenwert und var2 der Textwert, dies entsprechend der Reihenfolge, in der die Zuweisung erfolgt. Wenn wir Beobachter sind, sehen wir, wie wir auch die Werte beider Variablen abwechseln können, was bei der Arbeit mit Funktionen praktisch ist.
Lua Sie können sogar die Anzahl der Werte für die Anzahl der vorhandenen Variablen anpassen, zum Beispiel wenn die Werteliste kleiner als die Variablenliste ist, erhalten die zusätzlichen Variablen den Werttyp Null standardmäßig als Werte, sehen wir uns ein Beispiel für diesen Prozess an:

Wie wir sehen, erhalten die ersten beiden Variablen ihre entsprechenden Werte und die letzte davon automatisch Null wie wir erklären. Es ist wichtig zu erwähnen, dass mehrere Zuweisungen nicht immer schneller sind als einfache Zuweisungen, aber sie ermöglichen uns, mehrere Rückgaben von einem Funktionsaufruf zu sammeln, um nur einige zu nennen.
Neben globalen Variablen, Lua Es unterstützt lokale Variablen, die im Gegensatz zu 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, machen wir sie mit dem reservierten Wort lokalDiese Variablen arbeiten in dem Block, in dem sie deklariert wurden, zum Beispiel können wir sagen, dass ein Block eine Kontrollstruktur oder eine Funktion sein kann, sehen wir uns das folgende Beispiel an:

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

Wenn wir dasselbe in unserem Terminal ausführen, werden wir sehen, dass das Ergebnis möglicherweise nicht das ist, was wir erwarten, und das 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 eingeschränkt sein kann, können wir die Trennzeichen verwenden Ende Um einen Block anzugeben und zu wissen, wie weit unsere lokalen Variablen den Gültigkeitsbereich haben, sehen wir uns ein Beispiel an, in dem wir dies tun können:

 do local var1 = 16 local var2 = var1 + 20 x = 5 y = x + var1 end - 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 ihr Geltungsbereich mit dem Block Ende, mal sehen:

Wir können betonen, dass die Verwendung lokaler Variablen in unseren Programmen eine gute Praxis ist, sie helfen uns, die globale Umgebung nicht mit unnötigen Namen zu berühren, auch dass der Zugriff auf diese Variablen viel schneller ist, als wenn wir dies mit globalen Variablen und schließlich diesen tun Variablen verschwinden, sobald ihr Gültigkeitsbereich endet, wodurch Speicherplatz frei wird, daher empfehlen wir ihre Verwendung, wann immer es möglich ist.
KontrollstrukturenWie alle anderen Programmiersprachen Lua stellt uns eine Reihe von Kontrollstrukturen zur Verfügung, die wir in unseren Programmen verwenden können Wenn mit Bedingungen umgehen und während, wiederholen Ja Pro für iterative Schleifen, wobei außer wiederholen mit dem expliziten Terminator bis um und die anderen enden mit Ende.
Wie in den meisten Programmiersprachen die Deklaration Wenn prüft eine Bedingung und führt den Teil der dann oder der Teil von anders, wobei letzteres optional sein kann, sehen wir uns eine Reihe dieser Bedingungen an, wie sie in unseren Programmen zu sehen sind:

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

Hier haben wir drei Arten von Operationen, die grundlegende mit der dann, verwenden Sie return, um einen Wert gemäß der Bedingung und einen etwas vollständigeren Code zurückzugeben, der eine Funktion aufruft. Außerdem können wir schreiben Wenn verschachtelt mit sonst, was uns erspart, mehrere verwenden zu müssen endet, mal sehen wie es aussieht:

 if operation == "+" then result = a + b elseif operation == "-" then result = a - b elseif operation == "*" then result = a * b elseif operation == "/" then result = a / b else error ("Ungültige Operation") end

Es ist wichtig zu beachten, dass dies nicht nur optimaler, sondern auch notwendig ist, da Lua hat nicht die Typdeklarationen schalten Daher wird diese Art von verschachtelten Bedingungen in unseren Programmen häufig vorkommen.
Wie in anderen Sprachen, Lua Bewerten Sie zuerst den Zustand der während, wenn die Bedingung falsch ist, endet die Schleife und andernfalls werden die folgenden Codezeilen ausgeführt und der Vorgang wiederholt, bis die Bedingung falsch ist. Sehen wir uns ein einfaches Beispiel an, um dies zu veranschaulichen:

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

Diese Aussage im Gegensatz zu der während ermöglicht es uns, den Code innerhalb der Bedingung zu wiederholen, bis er wahr ist, wobei sogar dieser Code mindestens einmal ausgeführt werden kann, da die Auswertung der Bedingung am Ende erfolgt, sehen wir uns ein Beispiel an:

 Zeile wiederholen = os.read () bis Zeile ~ = "" print (Zeile)

In Bezug auf iterative Zyklen Pro, Lua hat zwei Varianten davon, die für numerisch und das generisch für. Schauen wir uns die Syntax der Zahl für an:

 für var = exp1, exp2, exp3 enden

Diese Schleife führt etwas für jeden Wert von aus var aus exp1 bis um exp2 mit exp3 als Wert, um var zu erhöhen oder zu verringern, wenn wir ihn nicht einschließen Lua geht standardmäßig davon aus, dass es nacheinander abläuft, sehen wir uns ein detaillierteres Beispiel dieser Zyklen an:

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

Wie wir sehen, ist seine Anwendung recht einfach und ermöglicht es uns, die nützlichen iterativen Zyklen in unseren Programmen zu implementieren. Sehen wir uns nun die Syntax für die an generisch für:

 for i, var in ipairs (array) drucken (var) end

Was dieser Zyklus macht, ist die Funktion zu verwenden, die er uns gibt Lua Forderung ipairs, ein Iterator von Arrays, wobei i für jede Iteration einen Index annimmt, während var den diesem Index zugeordneten Wert erhält.
Wie wir die Aussagen darin sehen Lua Sie unterscheiden sich nicht wesentlich von anderen Sprachen, aber die Sprache fügt diese zusätzliche Einfachheit hinzu, um uns ein viel schnelleres Erlernen ihrer Syntax und eine viel effektivere Verwendung zu ermöglichen. Damit beenden wir dieses Tutorial, in dem wir die Aufgaben und Kontrollstrukturen innerhalb von . gelernt haben Lua, und fügt so eine weitere Wissensebene hinzu, wenn es um diese einfache, aber mächtige Sprache geht.