Lua-Tutorial | Die Grundlagen der Script-Sprache lernen

Bei Lua handelt es sich um eine in Brasilien Anfang der 90er-Jahre entwickelte Script-Sprache. Der Quelltext eines Lua-Programms wird vom Lua-Interpreter in Bytecode übersetzt und ausgeführt. Der Interpreter selbst ist in C geschrieben, was Lua-Programmen in der Ausführung zu hoher Performanz verhilft. Ferner ermöglicht das C-API es, Lua-Code in C/C++ Programmen einzubetten. Lua ist eine Multiparadigmensprache, die sich zum Schreiben von imperativem, funktionalem und objektorientiertem Code eignet.

Das stärkste Alleinstellungsmerkmal von Lua ist die einfache Einbettung in andere Systeme und Sprachen. Lua hat sich damit als „Glue Language“ etabliert und kommt in vielen Game-Engines zum Einsatz. Die Sprache lässt sich zudem zur Steuerung von Webservern wie Apache und nginx nutzen. Über die CGI-Schnittstelle wird Lua oft auch als eigenständige Internet-Programmiersprache verwendet. Ferner kommt die Sprache zur Programmierung mobiler Apps zum Einsatz.

Lua Scripting Tutorial: Die ersten Schritte

Der einfachste und schnellste Weg, mit Lua programmieren zu lernen, besteht darin, Lua-Code auf der interaktiven Lua-Demo-Seite auszuführen. Sie können alle im weiteren Verlauf des Artikels dargestellten Lua-Code-Beispiele testen. Kopieren Sie eines der Code-Beispiele in das Textfeld und klicken Sie auf „run“, um den Code auszuführen.

Auf diesem Weg sparen Sie sich die Installation. Sollten Sie Lua auf dem eigenen System nutzen wollen, folgen Sie unseren weiteren Anweisungen. Andernfalls gehen Sie gleich weiter zum Abschnitt „Die Grundlagen der Lua-Scriptsprache erlernen“.

Interaktive Lua-Demo — Nutzen Sie die interaktive Lua-Demo, um die Code-Beispiele des Tutorials zu testen. / Quelle: http://www.lua.org/demo.html

Das eigene System für das Lua-Tutorial vorbereiten

Der Lua-Interpreter besteht aus einer einzigen Binärdatei, die auf der Kommandozeile nach dem Befehl „lua“ bereitsteht. Diese wird auf dem System abgelegt und muss ggf. in den Pfad aufgenommen werden. Ferner bietet Lua Bibliotheken, die die Einbettung von Lua-Code in C/C++ Programmen ermöglichen.

Für die Installation unter Mac und Linux bietet sich die Installation mit dem „Homebrew“-Paketmanager an. Wenn Sie auf Ihrem System Homebrew installiert haben, nutzen Sie am besten den folgenden Befehl auf der Kommandozeile, um Lua zu installieren:

Um Lua auf einem Windows-System zu installieren bietet sich der LuaDist-Installer an.

Den Lua-Interpreter interaktiv nutzen

Wie bei vielen Script-Sprachen üblich, lässt sich der Lua-Interpreter interaktiv ausführen. Im interaktiven Modus nimmt der Interpreter auf der Kommandozeile Lua-Code entgegen und führt diesen zeilenweise aus. Die dabei erzeugte Werte werden direkt auf der Kommandozeile ausgegeben. Als Nutzer kann man dann die Werte von Variablen überprüfen und ändern. Somit eignet sich dieser Ansatz besonders zum schnellen Prototypisieren. Um den Lua-Interpreter im interaktiven Modus zu starten, führen wir auf der Kommandozeile den folgenden Befehl aus:

# Lua-Interpreter im interaktiven Modus starten
lua -i

Nutzen Sie den Lua-Interpreter im interaktiven Modus, um die Code-Beispiele des Tutorials auf Ihrem lokalen System auszuführen.

# Lua-Script ausführen
lua <dateiname>.lua

#!/usr/local/bin/lua
-- Lua Code für die Ausführung

# Speicherort der Lua-Binärdatei ermitteln
which lua

# Lua-Datei als ausführbar markieren
chmod u+rx <dateiname>.lua

Lua-Script mit Hashbang ausführbar machen — Versehen Sie ein Lua-Script mit einem Hashbang, können Sie die Datei direkt ausführen. Links die dazu benötigten Befehle auf der Kommandozeile, rechts das Beispiel-Script.

-- diese Zeile wird vom Interpreter ignoriert

--[[
Dieser Kommentar
erstreckt sich über
mehrere Zeilen.
]]

Typ	Erklärung
number	Dezimalzahl
string	Zeichenfolge
boolean	Wahrheitswert: „true“ oder „false“
nil	Fehlender Wert; Typ hat nur den Wert „nil“
function	Funktion
table	Zusammengesetzter Datentyp: Liste / Array, Hash / Dictionary
thread	Coroutinen
userdata	Benutzer-definierter C-Datentyp

type(42) -- Typ ist `number`
type("Lua Tutorial") -- Typ ist `string`
type(false) -- Typ ist `boolean`
type(var) -- Typ ist `nil`, da `var` nicht definiert ist

-- Arithmetische Operation in Lua
1 + 2 -- evaluiert zum Wert `3`
-- String-Konkatenation in Lua
'Walther' .. 'White' -- evaluiert zu `WaltherWhite`
-- String-Konkatenation mit automatischer Umwandlung einer Zahl in Lua
'Die ' .. 3 .. ' Musketiere' -- evaluiert zu `Die 3 Musketiere`
-- Gleichheits-Test in Lua
7 == '7' -- evaluiert zu `false`
-- Gleichheits-Test in Lua
'klein' == string.lower('KLEIN') -- evaluiert zu `true`
-- dynamische Typ-Information
type(var) == 'nil' -- evaluiert zu `true`, da `var` nicht definiert

for = "Peter" -- ruft Fehler hervor
for_user = "Peter" -- erlaubt

anzahl = 13 -- das ist OK
13 = anzahl -- ruft Fehler hervor, da der Zahl 13 kein neuer Wert zugewiesen werden kann

Arithmetische Operator	Arität	Operation
+	binär	Addition
–	binär	Subtraktion
*	binär	Multiplikation
/	binär	Division
%	binär	Modulus
^	binär	Potenzierung
–	unär	Negation

Relationaler Operator	Test
==	Gleichheit
~=	Ungleichheit
>	Größer als
<	Kleiner als
>=	Größer als oder gleich
<=	Kleiner als oder gleich

Logischer Operator	Arität	Operation
and	binär	UND-Verknüpfung
or	binär	ODER-Verknüpfung
not	unär	Negation

Operator	Arität	Operation
..	binär	String-Konkatenation
#	unär	Anzahl Elemente eines Tables / Länge eines Strings ermitteln

preis = 42.99
rabatt = 0.15 -- 15% Rabatt
preis -= preis * rabatt -- `-=` funktioniert in Lua nicht
-- Dekrementierung muss stattdessen explizit geschrieben werden
preis = preis - (preis * rabatt)

-- diese Variable ist global
x = 5
-- lokale Variable definieren
local z = 10

-- äußerer Gültigkeitsbereich
do
  local x = 1
  do -- innerer Gültigkeitsbereich
    local y = 2
    -- `z` im globalen Gültigkeitsbereich erzeugen
    -- dabei Zugriff auf lokale Variable `x` von äußerem Gültigkeitsbereich
    -- sowie lokale Variable `y` vom inneren Gültigkeitsbereich
    z = x + y -- `z` hat jetzt den Wert `3`
  end
  print(x) -- gibt `1` aus
  print(y) -- gibt `nil` aus, da `y` im äußeren Gültigkeitsbereich nicht existiert
  print(z) -- gibt `3` aus
end
-- `z` ist global, existiert also außerhalb des äußeren Gültigkeitsbereich
z = z + 4
print(z) -- gibt `7` aus

limit = 42;
zahl = 43;
if zahl < limit then
  print("Unter dem Limit.")
elseif zahl == limit then
  print("Genau am Limit…")
else
  print("Über dem Limit!")
end

limit = 10
zahl = 1
while zahl <= limit do
  print("Zahl:", zahl)
  zahl = zahl + 1
end
-- Achtung: obwohl `zahl` bereits größer als `limit`
-- wird der Schleifenkörper einmal ausgeführt
zahl = 11
repeat 
  print("Zahl:", zahl)
  zahl = zahl + 1
until zahl > limit

anfang = 1
ende = 10
for zahl = anfang, ende do
  print("Aktuelle Zahl:", zahl) -- `1,2,3,4,5,6,7,8,9,10`
end
-- explizit Schritt auf `2` setzen
schritt = 2
for zahl = anfang, ende, schritt do
  print("Aktuelle Zahl:", zahl) -- `1,3,5,7,9`
end
-- der Schritt kann auch negativ sein
schritt = -2
-- mit negativem Schritt Anfang und Ende vertauschen, um absteigend zu zählen
for zahl = ende, anfang, schritt do
  print("Aktuelle Zahl:", zahl) -- `10,8,6,4,2`
end

-- Liste von Jahren definieren
dekaden = {1910, 1920, 1930, 1940, 1950, 1960, 1970, 1980, 1990}
-- mittels Iterator auf die einzelnen Jahre zugreifen
for index, jahr in ipairs(dekaden) do
  print(index, jahr)
end

-- Prozedur definieren
function hallo(name)
  print("Guten Tag", name)
end
-- Funktion aufrufen
hallo("der feine Herr")
-- auch dies ist möglich
hallo "der feine Herr"
-- folgendes funktioniert jedoch nicht
name = "Walther"
hallo name -- Syntax-Fehler
-- mit Variable statt Literal muss die Funktion mit Klammern aufgerufen werden
hallo(name)

-- Funktion mit einzelnem Rückgabewert
function quadrat(zahl)
  -- der Ausdruck `zahl * zahl` wird evaluiert
  -- und sein Wert zurückgegeben
  return zahl * zahl
end
-- Zahl quadrieren
print(quadrat(9)) -- `81`

-- alle Argumente einer Funktion drucken
function var_args(...)
  for index, arg  in ipairs({...}) do
    print(index, arg)
  end
end
var_args('Peter', 42, true)

-- Funktion mit mehreren Rückgabewerten
function erster_und_letzter(liste)
  -- erstes und letztes Element der Liste zurückgeben
  -- einzelne Rückgabewerte werden durch ein Komma `,` getrennt
  return liste[1], liste[#liste]
end
leute = {"Jim", "Jack", "John"}
-- Zuweisung der Rückgabewerte an mehrere Variablen
erster, letzter = erster_und_letzter(leute)
print("Der erste ist", erster)
print("Der letzte ist", letzter)

function min_mittel_max(...)
  -- Anfangswerte für `min` und `max` auf erstes Argument setzen
  local min = select(1, ...)
  local max = select(1, ...)
  -- Mittelwert anfangs auf null setzen
  local mittel = 0
  -- über den Zahlen iterieren
  -- die Index-Variable benötigen wir nicht
  -- und nutzen daher `_` als Platzhalter
  for _, zahl  in ipairs({...}) do
    -- ggf. neues Minimum setzen
    if min > zahl then
      min = zahl
    end
    -- ggf. neues Maxiumum setzen
    if max < zahl then
      max = zahl
    end
    -- für den Durchschnitt Zahlen summieren
    mittel = mittel + zahl
  end
  -- Summe der Zahlen durch deren Anzahl teilen
  mittel = mittel / #{...}
  return min, mittel, max
end
-- hier benötigen wir den `mittel`-Wert nicht
-- und nutzen daher `_` als Platzhalter
min, _, max = min_mittel_max(78, 34, 91, 7, 28)
print("Minimum und Maximum der Zahlen sind", min, max)

-- `map()`-Funktion in Lua
-- nimmt eine Funktion `f` und eine Liste als Argumente entgegen
function map(f, liste)
  -- neue Liste für Ausgabewerte anlegen
  local _liste = {}
  -- über den Elementen der Liste mit Index iterieren
  for index, wert in ipairs(liste) do
    -- Funktion `f()` auf den aktuellen Wert der Liste anwenden
    -- und den Rückgabewert in neuer Liste am selben Index speichern
    _liste[index] = f(wert)
  end
  -- neue Liste zurückgeben
  return _liste
end
-- Liste von Zahlen
zahlen = {3, 4, 5}
-- Funktion, die auf alle Elemente der Liste angewandt wird
function quadrat(zahl)
  return zahl * zahl
end
-- erzeugen der Quadrate via `map()`-Funktion
quadrate = map(quadrat, zahlen) -- `{9, 16, 25}`
-- quadrierte Zahlen ausgeben
for _, zahl in ipairs(quadrate) do
  print(zahl)
end

function f()
  -- rekursiver Aufruf
  f() -- verweist ggf. auf globale Variable `f`
end
-- stattdessen
local function f()
  -- rekursiver Aufruf
  f() -- verweist auf die umgebende Funktion
end
-- equivalent zu
local f; -- Variable `f` explizit als `local` deklarieren
f = function() -- Zuweisung der Funktion an die lokale Variable `f`
  f() -- verweist garantiert auf die umgebende Funktion
end

Lua Scripting Tutorial: Die ersten Schritte

Das eigene System für das Lua-Tutorial vorbereiten

Den Lua-Interpreter interaktiv nutzen

Lua-Script für das Tutorial mit dem Lua-Interpreter ausführen

Lua-Script für das Tutorial mittels Hashbang direkt ausführbar machen

Die Grundlagen der Lua-Script-Sprache erlernen

Kommentare in Lua-Scripten nutzen lernen

Werte und Typen für das Lua-Scripting-Tutorial

Gültigkeitsbereiche und Blöcke für das Lua Script-Tutorial verstehen

Mit den Lua-Kontrollstrukturen Programmieren lernen

Mehr über Funktionen mit Lua lernen

Kommentar verfassen Kommentieren abbrechen