Lua
Lua (portugiesisch für Mond) ist eine imperative und erweiterbare Skriptsprache zum Einbinden in Programme, um diese leichter weiterentwickeln und warten zu können. Eine der besonderen Eigenschaften von Lua ist die geringe Größe des kompilierten Skript-Interpreters.
| Lua | |
|---|---|
 Lua-Logo | |
| Basisdaten | |
| Paradigmen: | Skriptsprache, imperativ, funktional |
| Erscheinungsjahr: | 1993 |
| Designer: | Roberto Ierusalimschy |
| Entwickler: | Roberto Ierusalimschy, Waldemar Celes, Luiz Henrique de Figueiredo |
| Aktuelle Version | 5.4.4[1][2] (26. Januar 2022) |
| Typisierung: | dynamisch, schwach (weak typing) |
| Wichtige Implementierungen: | Lua, LuaJIT[3], LLVM-Lua[4], LuaCLR[5] |
| Dialekte: | Metalua, Idle, GSL Shell |
| Beeinflusst von: | C++, CLU, Modula, Scheme, SNOBOL |
| Beeinflusste: | Falcon, GameMonkey, Io, JavaScript, Julia, MiniD, MoonScript, Red, Ruby, Squirrel |
| Betriebssystem: | plattformunabhängig |
| Lizenz: | MIT-Lizenz |
| www.lua.org | |
Lua-Programme sind meist plattformunabhängig und werden vor der Ausführung in Bytecode übersetzt. Obwohl man mit Lua auch eigenständige Programme schreiben kann, ist sie vorrangig als eingebettete Skriptsprache für andere Programme konzipiert. In dieser Hinsicht ist sie mit Tcl vergleichbar. Vorteile von Lua sind die geringe Größe von 120 kB, die Erweiterbarkeit und die hohe Geschwindigkeit, verglichen mit anderen Skriptsprachen.
Der Lua-Interpreter kann über eine C-Bibliothek angesprochen werden, die auch ein API für die Laufzeitumgebung des Interpreters für Aufrufe vom C-Programm aus enthält. Mittels des API können verschiedene Teile des Programmes in C (oder C++) und Lua geschrieben werden, während Variablen und Funktionen in beiden Richtungen erreichbar bleiben (d. h. eine Funktion in Lua kann eine Funktion in C/C++ aufrufen und umgekehrt).
Es gibt auch einen freien JIT-Compiler namens LuaJIT, der die Revision 5.1 der Sprache unterstützt.[3]
Lua ist in ANSI-C implementiert und unterstützt imperative und funktionale Programmierung. Implementiert man jedoch selbst Objekte mittels Metatables, wird auch objektorientierte Programmierung möglich.
Geschichte
Lua wurde 1993 von Roberto Ierusalimschy, Luiz Henrique de Figueiredo und Waldemar Celes in der Computer Graphics Technology Group der Päpstlichen Katholischen Universität von Rio de Janeiro in Brasilien entwickelt. Lua ist freie Software und wurde bis zur Version 4 unter einer eigenen BSD-Lizenz veröffentlicht, ab Version 5 unter der MIT-Lizenz.
Verwendung
Lua kann sowohl zum Verfassen eigenständiger Programme verwendet werden als auch als eingebettete Sprache dienen.
Um einzelne Komponenten eines Computerspiels wie z. B. Konfigurationsdateien oder die KI von computergesteuerten Charakteren oder Gegnern von der Spiel-Engine zu trennen, kommt Lua bei der Entwicklung von Computerspielen oft zum Einsatz. Dies macht die meist teuer entwickelte Spiel-Engine flexibler und ermöglicht eine mit geringerem Aufwand verbundene Wiederverwendbarkeit, weshalb Lua im Bereich proprietärer Spiele verwendet wird. Lua wird zum Beispiel in dem bekannten Spiel "Roblox" verwendet.
Auch einige insbesondere dynamische und Tiling-Fenstermanager nutzen Lua für Konfiguration und Steuerung, darunter awesome[6] und Ion3.
Syntax
Datentypen
Neben den Datentypen nil, boolean, number (mit den internen Subtypen integer und float), string, function, userdata und thread kennt Lua als einzigen strukturierten Datentyp table (Tabelle).
Eine Tabelle ist ein assoziatives Datenfeld, also eine Ansammlung von Schlüssel-Daten-Paaren. Der Schlüssel (Index) kann dabei jeden Datentyp (außer nil) besitzen. Weiterhin wird unterschieden zwischen dem Zahlenschlüssel 1 und dem Stringschlüssel "1". Die Indizierung von Tabellen beginnt im Gegensatz zu C-ähnlichen Sprachen mit 1.
Tabellen können auf folgende Weisen erzeugt werden:
T = {} -- Erzeugt eine leere Tabelle und weist sie der Variablen mit dem Namen T zu.
T = {"ja", "nein", "?"} -- Eine Tabelle mit 3 Elementen, wobei T[1] == "ja", T[2] == "nein" und T[3] == "?".
T = {[1] = "ja", [2] = "nein", [3] = "?"} -- Wie Zeile vorher, nur mit expliziter Indizierung.
T = {[-900] = 3, [900] = 4} -- Tabelle mit 2 Elementen, aber unregelmäßigen Indizes.
T = {x=5, y=10} -- Typisches assoziatives Datenfeld mit T["x"], T["y"] (auch als T.x, T.y zugreifbar)
T = {x=5, y=10; "ja", "nein"} -- Gemischte Tabelle mit T.x, T.y, T[1], T[2]
T = {Nachricht = "wahl", {"ja", "nein", "?"}} -- Tabellen können weitere Tabellen enthalten.
Zuweisungen
a = 5
b = "hi"
local a = a
-- Einfache Zuweisungen. Variablen sind nicht typisiert und können verschiedene Datentypen haben.
-- Lokale Variablen (definiert mit "local") sind auf den aktuellen Namensbereich beschränkt.
a, b, c = 1, 2, 3 -- Mehrfachzuweisungen sind erlaubt.
a, b = b, a -- Wertetausch: Anweisungen werden von rechts nach links ausgewertet.
a, b = 4, 5, "6" -- Überflüssige Werte (Bsp: "6") werden ausgewertet, aber verworfen.
a, b = "da" -- Fehlende Werte auf der rechten Seite werden mit "nil" ersetzt.
a = nil -- Zerstört a. Der Speicherbereich von a wird vom Garbage-Collector freigegeben.
a = z -- Falls z nicht definiert ist, wird "nil" zugewiesen und somit a freigegeben.
a = "3" + "2" -- Der Operator + erwartet Zahlen, die Zeichenketten werden also
-- in Zahlen konvertiert, also erfolgt hier die Zuweisung a = 5.
a = 3 .. 2 -- Der Verbindungsoperator erwartet Zeichenketten, die Zahlen werden
-- konvertiert - a = "32".
local a <const> = 5 -- lexikalische (lokale) Konstanten wurden in Lua 5.4 eingeführt
local f <close> = io.open(file) -- ebenfalls ab 5.4: to-close-Variablen mit ähnlicher Semantik
-- wie Pythons Context Manager (with ...)
Funktionen
Funktionen können mit dem Schlüsselwort function erzeugt werden. Funktionen besitzen keine fixierte Anzahl an Parametern und Rückgabewerten.
function probe(zahl1, zahl2, text, tabelle)
zahl3 = zahl1 + zahl2
zahl4 = zahl1 - zahl2
print(text)
if tabelle ~= nil then
print(tabelle.eintrag)
end
return zahl3,zahl4
end
probe(10, 20, "Hallo ", {eintrag = "Welt"}) -- erlaubter Funktionsaufruf
x,y = probe(10,20) -- ebenfalls erlaubter Aufruf, text und tabelle sind nil.
Beim Aufruf der Funktion müssen nicht alle Variablen übergeben werden. Fehlende Parameter besitzen automatisch den Nullwert nil. Dasselbe gilt für Rückgabewerte. Dadurch lassen sich Funktionsüberladungen einfacher implementieren, das Vorkommen von Laufzeitfehlern steigt jedoch.
Reservierte Schlüsselwörter
and break do else elseif end false for function goto if in
local nil not or repeat return then true until while
Das Schlüsselwort nil steht (neben false) für falsch und generell für nicht initialisierte Variablen oder nicht interpretierbare Werte.
Beispielcode
Das klassische Hallo-Welt-Programm sieht wie folgt aus:
print("Hallo Welt!")
Kommentare können einzeilig sowie mehrzeilig verfasst werden:
-- Ein Kommentar in Lua beginnt mit zwei Bindestrichen und geht bis zum Ende der Zeile.
--[[Kommentare können auch über mehrere
Zeilen ausgeweitet werden, sodass die Dokumentation
des Quellcodes leichter fällt.]]
Beispiel für eine Rekursion (Berechnung der Fakultät):
function factorial(n)
if n == 0 then
return 1
end
return n * factorial(n - 1)
end
Mit den Kurzschlussoperatoren „and“ und „or“ kann die Funktion kürzer so geschrieben werden (dies entspricht dem Auswahloperator ?: von C und verwandten Sprachen):
function factorial(n)
return n == 0 and 1 or n * factorial(n - 1)
end
Funktionen gelten in Lua als First-Class-Objekte. Das bedeutet insbesondere, dass Funktionen während der Laufzeit dynamisch erzeugt und (auch vorhandenen) Variablen zugewiesen werden können. Das folgende Beispiel zeigt, wie die Variable print (welche auf eine Standardfunktion der Lua-Bibliothek zeigt) mit einer anderen Funktion überschrieben wird:
do
local oldprint = print -- aktuelle (globale) print-Funktion über oldprint zugreifbar machen
function print(s) -- Neue (globale) Definition von print, ...
oldprint("I say: " .. s) -- ... die die alte print-Funktion aufruft.
end
end
Befehle in Lua können mit einem Semikolon abgeschlossen werden. Falls mehrere Befehle in einer Zeile stehen, erleichtert dies die Lesbarkeit des Codes.
Die Syntax lehnt sich an die von Pascal an, was besonders Anfängern den Einstieg in Lua erleichtert. Im Gegensatz zu von Pascal abgeleiteten Sprachen nutzt Lua jedoch „==“ und nicht „=“ als Vergleichsoperator, „=“ als Zuweisungsoperator (anstelle von „:=“ in Pascal) und „~=“ für ungleich (anstelle von „<>“).
Module
Lua ist durch benutzerdefinierte Module beliebig erweiterbar. Um diese zu verwalten, ist der in Lua geschriebene Paketverwalter LuaRocks verfügbar.
Eine Liste mit verbreiteten Lua-Modulen:
| Modul | Beschreibung |
|---|---|
| LuaFileSystem | Zugriff auf Ordnerstrukturen und Dateieigenschaften. |
| LuaDoc | Dokumentationstool für Lua-Quellcode. |
| LuaSocket | Bibliothek für Socketprogrammierung. |
| LuaSQL | Lua-Interface für PostgreSQL, ODBC, MySQL, SQLite, Oracle, und OLE DB. |
| stdlib | Bibliothek für häufige Programmieraufgaben; bezieht sich auf Listen, Tabellen, funktionale Programmierung, Reguläre Ausdrücke, Objekte, Pretty-Printing und getopt. |
| MD5 | einfache kryptografische Hashfunktion |
| Copas | Dispatcher, basierend auf Co-Routinen, der von TCP/IP-Servern verwendet werden kann. |
| LuaZip | Bibliothek, die von ZIP-Dateien lesen kann. |
| LuaInterface | Verbindung zwischen Lua und Microsofts .NET Common Language Runtime (CLR). |
| LuaBitOps | Eine auf C basierende Erweiterung für Lua für bitweise Operationen von Zahlen. |
| LuaXML | Einfache Verbindung zwischen XML und Lua. |
| Lanes | Ermöglicht das parallele Laufen von verschiedenen Lua-Umgebungen. |
| Penlight | Bibliothek, die den Umgang mit Tabellen, Arrays, Strings, Dateipfaden, Ordnern, Daten und funktionalen Programmieranwendungen vereinfacht. |
| Oil | Einfacher und effizienter Object Request Broker (CORBA). |
Literatur
- Roberto Ierusalimschy: Programmieren in Lua, 4. Auflage, Open Source Press, 2016, ISBN 978-8-59037-986-7.
- Roberto Ierusalimschy, L. H. Figueiredo, W. Celes: Lua 5.1 Reference Manual, August 2006, ISBN 85-903798-3-3.
- Kurt Jung, Aaron Brown: Beginning Lua Programming, Wrox, 2007, ISBN 0-470-06917-1.
- Claus Kühnel, Daniel Zwirner: Lua: Einsatz von Lua in Embedded Systems, 2. Auflage, Skript Verlag Kühnel, 2012, ISBN 978-3-90785-715-1.
- David Young: Learning Game AI Programming with Lua, Packt Publishing, 2014, ISBN 1-783-28133-2.
Weblinks
- Lua.org – offizielle Website (englisch und portugiesisch)
- Lua Unofficial FAQ
- LuaRocks – Paketmanager und -repository
- Lua Users Wiki
- Awesome Lua auf GitHub
- Learn Lua in 15 Minutes
- Schnelles, leichtgewichtiges, eingebettetes Scripting mit Lua von Jan Bornholdt, Fachhochschule Wedel
Quellen und Anmerkungen
- Lua 5.4.4 now available. 26. Januar 2022 (englisch, abgerufen am 28. Januar 2022).
- github.com. 27. Januar 2022 (abgerufen am 28. Januar 2022).
- LuaJIT. Abgerufen am 26. Februar 2017 (englisch).
- LLVM-Lua. Abgerufen am 26. Februar 2017 (englisch).
- LuaCLR. Abgerufen am 3. Januar 2016 (englisch).
- Julien Danjou: Why not Lua, abgerufen am 19. Juni 2021.