Variablen sind Behälter für einen beliebigen Wert, den man mit Lua ausdrücken kann. Eine Variable besteht aus ihrem Namen (Key) und ihrem Inhalt (Value). Über ihren Namen kann eine Variable eindeutig identifiziert bzw. ihr Inhalt abgerufen werden.
In Lua wird eine Variable definiert, indem ihr Name, gefolgt von einem =-Zeichen, einem Wert zugewiesen wird.

Ein Beispiel:

Result = 42

Der Name dieser Variable ist Result, ihr Inhalt 42. Eine Variable auf diese Art zu definieren wird auch Zuweisung genannt, wie im Kochrezeptbeispiel erklärt.

Beim Namen für eine Variable ist zu beachten, dass zwischen Groß- und Kleinschreibung unterschieden wird. Folgender Code würde zwei verschiedene Variablen erschaffen, die nichts miteinander zu tun haben:

Result = 42
result = 41

Auch dürfen in Variablennamen ausschließlich Groß- und Kleinbuchstaben (ausgenommen Umlaute), Ziffern und der Unterstrich vorkommen. Der Variablenname darf nicht mit einer Ziffer beginnen. Wir listen einige gültige und ungültige Variablennamen im folgenden Beispiel auf:

Result = 42     -- gültig
_Result = 42    -- gültig
R3su1t = 42     -- gültig
 
4tytwo = 42     -- ungültig!
Zaubärzahl = 42 -- ungültig!
 
-- Wir verwenden ab jetzt regelmäßig diese Kommentare in Codebeispielen.
-- Kommentare sind kein Programmcode, sondern machen den gegebenen Code durch
-- unterstützende Erklärungen besser verständlich.
-- Kommentare werden in Lua mit -- eingeleitet

Wichtig: Einige Namen für Variablen sind unzulässig, da sie von Lua intern reserviert sind. Alle unzulässigen Namen sind hier aufgelistet:

Wichtig: Das =-Zeichen bei der Variablenzuweisung hat nichts mit dem =-Zeichen zu tun, wie man es aus der Mathematik kennt. Man kann nicht einfach ein Gleichungssystem ins Skript tippen, das dann vom Programm gelöst wird!
Eine Zuweisung arbeitet in einer fest vorgegebenen Reihenfolge:

1. Nimm den Wert, der rechts vom =-Zeichen steht
2. Speichere diesen Wert unter dem Namen, der auf der linken Seite steht, ab

Dementsprechend müssen die Werte, die jeweils links und rechts vom = stehen, nicht notwendigerweise gleich sein. Dies wird offensichtlich, wenn man beginnt, mit Variablen zu rechnen. Dazu folgen nun einige Kapitel für die jeweiligen Datentypen, die eine Variable halten kann.

Hinweis: Unsere Beispiele in diesem und den folgenden Kapiteln können besser nachvollzogen werden, wenn man die Programmzeilen nebenbei ausprobieren kann. Dazu kann man diese Webseite hier verwenden:

https://www.lua.org/demo.html

Um dabei bei der Ausgabe ein Ergebnis zu sehen, kann man print verwenden. Will man beispielsweise die Variable Result ansehen, kann man

Result = 42
print(Result)

schreiben. Wenn die Variable einen anderen Namen hat, muss man diesen dementsprechend austauschen.

Lua kann sowohl mit ganzen Zahlen als auch Dezimalzahlen arbeiten. Bei letzteren ist zu beachten, dass das Dezimaltrennzeichen kein Komma, sondern ein Punkt ist:

DecimalNumber = 4.2

Für Zahlen stehen in Lua die gängigen Rechenoperationen zur Verfügung:

 Result = 40 + 2 

 Result = 48 - 6 

 Result = 7 * 6 

 Result = 84 / 2 

 Result = 3.4761^3 

 Result = - (- 42) 

Im letzten Beispiel haben wir noch Klammern eingesetzt, um die Berechnungsreihenfolge festzulegen. Ohne Klammerung gilt Punkt vor Strich (bzw. Exponentiation hat die höchste Priorität von allen). Für einige weitere mathematische Operationen siehe die math-Übersicht.

Wenn man mehr als eine Variable hat, kann man diese auch untereinander verrechnen:

FirstNumber = 32
SecondNumber = 2
ThirdNumber = 0.5
FourthNumber = 10.5
Result = ( FirstNumber / SecondNumber )^ThirdNumber * FourthNumber

An folgendem Beispiel kann man leicht erkennen, dass das =-Zeichen der Zuweisung dient und keinen mathematisch korrekten Ausdruck formuliert:

FirstNumber = 5
-- Berechne zuerst den Wert rechts vom = : Das ergibt 15, weil FirstNumber zu dem 
-- Zeitpunkt noch den Wert 5 hat. Erst danach wird 15 als die neue FirstNumber abgespeichert
FirstNumber = FirstNumber + 10
SecondNumber = FirstNumber - 3
SecondNumber = SecondNumber / 2
ThirdNumber = FirstNumber * SecondNumber
ThirdNumber = ThirdNumber - 48

Strings sind Zeichenketten und werden meistens für die Darstellung von Text verwendet. Strings beginnen und enden mit Anführungszeichen:

Text = "Hallo Welt"

Strings können mit zwei aufeinanderfolgenden Punkten miteinander verkettet werden:

Text1 = "Hallo "
Text2 = "Welt"
Text3 = Text1..Text2

Auf diese Art verkettet können auch Variablen mit Zahlenwert in einen String eingefügt werden:

MyNumber = 42
Text = "Die Antwort lautet "..MyNumber.."! Großartig!"

Es gibt einige Zeichen, die in einem String nicht ohne Weiteres verwendet werden können. Eines davon ist logischerweise das Anführungszeichen, da es einen String beendet bzw. einleitet. Um ein Anführungszeichen dennoch in einem String verwenden zu können, muss es mit einem Backslash „escaped“ werden:

-- Wir haben hier den Text in zwei Zeilen geschrieben und mit .. miteinander verbunden, um
-- horizontales Scrollen zu vermeiden. Dies sorgt in Skripten für bessere Übersicht
DrEvil = "Back in the sixties I developed a weather changing machine which was, in essence, "..
         "a sophisticated heat beam which we called a \"laser\""

Ein anderes Zeichen, das in Strings nicht einfach verwendet werden kann, ist als Resultat der Backslash. Ein einzelner Backslash muss daher mit zwei Backslashes definiert werden. Das ist vor allem bei der Angabe von Dateipfaden wichtig:

Path = "C:\\Games\\SettlersHoK"

Booleans können nur einen von zwei verschiedenen Werten annehmen: Wahr (true) oder Falsch (false). Damit wird der Wahrheitsgehalt einer Aussage ausgedrückt. Verzweigungen und Schleifen funktionieren nur, indem sie Bedingungen prüfen. So eine Bedingung kann zum Beispiel sein, ob sich ein Siedler in der Nähe einer bestimmten Position befindet. Die Antwort darauf ist entweder Wahr oder Falsch.

CatsAreCute = true
FeathersAreHeavy = false

Mit booleans kann man auch „rechnen“. Lua bietet dafür drei verschiedene Funktionen an (im Weiteren logische Operatoren genannt):

Und (and) prüft, ob zwei verschiedene Booleans beide wahr sind.

Result = Boolean1 and Boolean2

Oder (or) prüft, ob von zwei verschiedenen Booleans mindestens einer wahr ist.

Result = Boolean1 or Boolean2

Nicht (not) kehrt den Wert eines Booleans um.

Result = not Boolean1

Sowohl Zahlen als auch Strings können miteinander verglichen werden, was ebenfalls in Booleans resultiert. Ein einfaches Beispiel ist hierbei die Frage, ob eine Zahl größer als eine andere ist:

Test = Number1 > Number2

Etwas ungewohnter ist die Frage, ob ein Text „größer“ als ein anderer ist. Strings sind lexikographisch geordnet, quasi wie in einem Wörterbuch. Wörter, die mit „A“ beginnen, sind kleiner als Wörter, die mit „B“ beginnen. Sind die ersten Buchstaben gleich, werden die zweiten verglichen, usw:

Test = "Hallo" < "Welt" -- true

Eine vollständige Liste aller Vergleichsoperatoren findest du hier:

 Test = a < b 

 Test = a > b 

 Test = a <= b 

 Test = a >= b 

 Test = a == b 

 Test = a ~= b 

Besonderes Augenmerk sei darauf gerichtet, dass die Frage nach Gleichheit mit zwei ==-Zeichen geschieht, da ein einzelnes =-Zeichen bereits für die Zuweisung reserviert ist.

Wenn du Variablen unterschiedlicher Datentypen miteinander vergleichst, bekommst du in der Regel eines von zwei verschiedenen Ergebnissen:

1. Ein Fehler. "0" < 1 ist kein gültiger Ausdruck, da ein String mit einer Zahl verglichen werden soll
2. false. "0" == 0 wirft keinen Fehler, da die beiden Eingabewerte nicht in ihrer „Größe“ miteinander verglichen, sondern nur deren Gleichheit festgestellt werden soll. Da ein String und eine Zahl intern aber völlig anders dargestellt werden, ist das Ergebnis negativ.

Achte deshalb immer darauf, dass deine Variablen vom richtigen Typ sind.

Diese logischen Operatoren haben ebenfalls eine „Punkt vor Strich“-Reihenfolge, die es (zusammen mit den Rechenoperationen) zu beachten gilt:

1. Exponentiation
2. not und Zahlennegation
3. Punktrechnung
4. Strichrechnung
5. Stringkonkatenation
6. Vergleichesoperatoren
7. and
8. or

Wobei höhere Priorität bedeutet, dass ein Operator vor einem anderen mit niedrigerer Priorität ausgeführt wird. Andere Reihenfolgen lassen sich ebenfalls mit Klammerung umsetzen:

Boolean1 = true
Boolean2 = false
Number1 = 5
Number2 = 8
Number3 = 13
Result1 = not Boolean1 and Boolean2 or Number3 > Number1*Number2
Result2 = ((not Boolean1) and Boolean2) or (Number3 > (Number1*Number2))
Result3 = not (Boolean1 and Boolean2) or (Number3 > (Number1*Number2))
 
-- Test1 ist wahr, da Result2 so geklammert ist, wie es ohnehin ausgerechnet werden würde
Test1 = Result1 == Result2
-- Test2 ist falsch, da die Klammerung bei Result3 für ein anderes Ergebnis sorgt
Test2 = Result1 == Result3

Achtung: Besondere Vorsicht ist geboten, wenn verschiedene Datentypen miteinander in Berührung kommen:

Test = not 5 > 7

Ohne Klammerung wird hier zuerst not 5 ausgewertet, was false ergibt. Dann wird geprüft, ob false > 7 ist, was in einem Laufzeitfehler resultiert. Der Ausdruck muss daher korrekt geklammert werden:

Test = not (5 > 7)

Ein weiterer Datentyp ist nil. Der Zweck dieses Datentyps ist einzig und allein, sich von allen anderen Datentypen zu unterscheiden und wird in der Regel benutzt, wenn keine sinnvollen Daten angegeben werden können:

Unicorns = nil

Der Vollständigkeit halber bleibt zu erwähnen, dass auch Tables und Funktionen Variablen sind. Die Erklärungen dazu finden sich in den entsprechenden Kapiteln.

Im nächsten Kapitel beschreiben wir, wie Programmcode nur unter bestimmten Bedingungen ausgeführt wird.

Voriges Kapitel: Was ist Programmierung
Nächstes Kapitel: Verzweigungen
Zurück nach oben