• müssen nicht definiert werden
  • alle Variablen existieren, haben ggf. den Wert nil
• dynamisch typisiert
• Bezeichner dürfen nicht mit einer Ziffer beginnen
• Bezeichner sollten nicht mit einem _ beginnen, da diese Variablen ggf. von lua selbst genutzt werden
• Variablen können folgende Typen annehmen (der Typ muss nicht deklariert werden)
  • string
    • immutable, wie in Python
      • ein String kann also nicht geändert werden, es kann nur ein neuer erstellt werden
    • kann dynamisch in number umgewandelt werden
      • bei Vergleichen allerdings nicht
    • tonumber(variable) wandelt explizit in number um
    • können beliebige Binärdaten beinhalten
  • number
    • ist float, es gibt kein int
    • wird dynamisch in strings umgewandelt
      • bei Vergleichen allerdings nicht
    • tostring(variable) wandelt es explizit in string um
  • nil
    • Variable hat keinen Wert → None in Python
  • function
    • Funktionen können Variablen zugewiesen werden
• bei Vergleichen sind false und nil false
  • leere Zeichenketten und 0 sind hingegen true

• mehrere Variablen können in einem Statement zugewiesen werden
  • werden mehr Variablen als Werte zugewiesen wird nil zugewiesen
  • werden mehr Werte als Variablen angegeben, werden die Werte ohne Meldung verworfen

a, g, f = 1, 3
</shx>
  * a = 1
  * g = 3
  * f = nil
      * da weniger Werte als Variablen angegeben
===== Kommentare =====

  * <code>--</code> leitet einen einzeiligen Kommentar ein
  * <code>--[[Sometext--]]</code> ist ein mehrzeiliger Kommentar


===== dofile =====

Importiert alles aus einer Datei in den lokalen Namespace.

<sxh lua>
dofile("somefile.lua)

Anschließend können die Funktionen in somefile.lua benutzt werden als wären sie in der lokalen Datei.
Im Prinzip wie wenn man in Python import x from y macht.

Definiert eine Funktion

function somename(parameter1, parameter2)
   somecode
end

Funktionen:

• beginnen mit function
• und enden mit end

• Key-Value-Maps
• ersetzen Arrays/Lists, Hashmaps/Dicts
• Keys können klassische Indexes (Zahlen) oder ein beliebiger anderer Datentyp sein, auch durcheinander
  • zu beachten ist allerdings das „1“ und 1 nicht der gleiche Index sind → das eine ist ein String, das andere eine Zahl
• Tables haben keine vordefinierte Anzahl von Einträgen (wie Arrays), sondern können beliebig verlängert/verkürzt werden
  • es werden keine Werte gespeichert, sondern Referenzen auf die eigentlichen Variablen
  • so wie Lists in Python
• Zugriff per Index oder in Objektnotation
• Einträge die nicht vorhanden sind liefern nil zurück

a={}  --Erstellt leere Table
print(a[5]) --Gibt nil zurück, da der Key nicht existiert
a.x=6 --Setzt den Index "x" auf 6
print(a["x"]) --Ergibt 6

• Variablennamen speichern Referenzen auf Tabellen, nicht aber die Tabelle selbst
  • im Gegensatz zu anderen Datentypen, wo tatsächlich der Wert gespeichert wird
  • tables sind Objekte, keine primitiven Datentypen und werden per Reference gespeichert

a="Hallo"
b=a --b hat jetzt auch den Wert "Hallo"
a="Anders"
print(b) --das gibt "Hallo" zurück, da der Wert von a an b kopiert wurde, nicht die Referenz
c={}
c.x=6
d=c --d und c verweisen jetzt auf die gleiche table als Referenz, nicht als Wert
d.x=8
print(c.x) --das gibt 8 zurück, da c und d auf die gleiche table verweisen, nicht auf den gleichen Wert

• die Funktion ipairs erlaubt for-Schleifen zu bauen die key und value zurückliefern
  • ähnlich .items() in Python für dicts

for key, value in ipairs(mytable) do
  print(key, value)
end

a={2,3,x=6}
print(a[1])
print(a["x"])

• hier wird eine gemischte Table erstellt, die ersten beiden Werte können über einen klassischen Index (1-x) angesprochen werden, der 3. Wert ist per named Index erreichbar („x“), so wie in einem dict/hashmap.
• das erste print gibt 2 zurück, es wird per index 1 zugegriffen
  • die Indexierung beginnt bei 1, nicht bei 0
  • es wird hier auf die Table wie auf eine normale Liste zugegriffen
• das zweite print gibt 6 zurück, es wird per index „x“ zugegriffen

Funktioniert über Funktionen.

• pairs() iteriert über alle Einträge einer Table und liefert den Key (Index) und den jeweiligen Wert zurück
  • gibt es einen expliziten Key (wie bei Hashmaps/Dicts) dann wird dieser zurückgegeben
  • gibt es keinen expliziten Key (wie bei Lists, arrays) wird der Index zurückgegeben
• ipairs() iteriert über alle Einträge mit numerischem Index und gibt Index und Wert zurück
  • Werte die einen expliziten Index/Key haben (wie bei einer Hashmap) werden nicht zurückgegeben

a={6,8,'bla'='blub', 99}
for key, value in pairs(a) do
    print(key, value)
end

for key, value in ipairs(a) do
    print(key, value)
end

• erste Schleife gibt aus:
  • 1 6
  • 2 8
  • bla blub
  • 99
• zweite Schleife gibt aus:
  • 1 6
  • 2 8
  • 3 99
  • der Key und Wert für 'bla' werden übersprungen, der Index ist fortlaufend → 'bla' wird nicht mitgezählt

• die üblichen
• also *, -, +, /

• < und >
• ⇐ und >=
• == - Gleichheit zweier Werte
  • außer bei tables, da müssen beide Variablen auf die gleiche table im Speicher verweisen, es wird nicht der Inhalt geprüft
• ~= → ungleich

• nil und false werden beide als false gesehen in logischen Ausdrücken, alles andere als true

• and - A und B müssen Wahr sein
  • wobei der erste Teil zurückgeben wird wenn er False ergibt
    • also nil and 5 → ergibt nil (nicht false wie man denken könnte)
  • wenn der erste Teil True ergibt wird der zweite Teil zurückgegeben
    • 5 and nil → ergibt nil
    • 5 and 6 → ergibt 6
  • oben stehendes Verhalten ist auch in python so
    • man sieht es nur meist nicht weil man „if whatever“ schreibt und if auf true oder false prüft, auch wenn das was vom Vergleich kam nicht der Wert true oder false war, sondern irgendetwas, es wird nur implizit konvertiert

• or - Einfaches Or → entweder A oder B muss wahr sein
  • es wird der erste Teil zurückgegeben wenn dieser Wahr ist
    • 5 or 6 → 5 → da 5 wahr
  • ansonsten der zweite Teil
    • nil or 6 → 6 → da der erste Teil nicht wahr ist
    • nil or false → false → da der erste Teil nicht wahr ist
  • oben stehendes Verhalten ist auch in python so
    • man sieht es nur meist nicht weil man „if whatever“ schreibt und if auf true oder false prüft, auch wenn das was vom Vergleich kam nicht der Wert true oder false war, sondern irgendetwas, es wird nur implizit konvertiert

• Verkettungen sind möglich

a and b or c

"bla" .. "blub"
a .. "Blub"

„..“ ist der Verkettungsoperator