Lua

Lua
Lua-Logo
Basisdaten
Paradigmen:	Skriptsprache, imperativ, funktional, objektorientiert
Erscheinungsjahr:	1993
Entwickler:	Roberto Ierusalimschy, Waldemar Celes, Luiz Henrique de Figueiredo
Aktuelle Version:	5.1.4  (22. August 2008)
Aktuelle Vorabversion:	5.2.0-beta  (8. Juli 2011)
Typisierung:	dynamisch, schwach (weak typing) („Duck-Typing“)
wichtige Implementierungen:	Lua, LuaJIT [1], LLVM-Lua[2], LuaCLR[3], Nua[4], Lua Alchemy[5]
Dialekte:	Metalua, Idle, GSL Shell
Einflüsse:	Scheme, SNOBOL, Modula, CLU, C++
Beeinflusste:	Io, GameMonkey, Squirrel, Falcon, MiniD,
Betriebssystem:	plattformunabhängig
Lizenz:	MIT-Lizenz
www.lua.org

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 wurde 1993 von 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, ab Version 5 unter der MIT-Lizenz veröffentlicht.

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. Insbesondere die geringe Größe von 120 kB, die Erweiterbarkeit und die hohe Geschwindigkeit verglichen mit anderen Skriptsprachen überzeugen viele Entwickler davon, Lua einzusetzen.

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 beinhaltet. Mittels des API können verschiedene Teile des Programmes in 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 aufrufen, und umgekehrt).

Es gibt auch einen freien JIT-Compiler für die neueste Version (5.1) von Lua namens LuaJIT^[6].

Lua ist in ANSI-C implementiert und unterstützt imperative und funktionale Programmierung. Implementiert^[7] man jedoch selbst Objekte mittels Metatables, wird auch objektorientierte Programmierung ermöglicht.

Die Sprache

Reservierte Schlüsselwörter

and break do else elseif end false for function if in
local nil not or repeat return then true until while

Das Schlüsselwort nil steht für eine nicht initialisierte Variable und entspricht dem null in C-ähnlichen Sprachen.

Tabellen

Tabellen(Tables) sind die einzige und fundamentale Datenstruktur in Lua. Alle Elemente können als Tabelle aufgefasst werden. Einzelne Variablen können als 1×1-Tabelle betrachtet werden.

Eine Tabelle ist eine Ansammlung von Schlüssel-Daten-Paaren, wie sie in einer Hashtabelle üblich ist. Der Schlüssel (Index) kann dabei jeden Datentyp (außer nil) haben. 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 = {"yes", "no", "?"} -- Eine Tabelle mit 3 Elementen wobei t[1] = "yes".
t = { [1] = "yes", [2] = "no", [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} -- Typische Hashtabelle mit t["x"], t["y"] (oder t.x, t.y)
t = {x=5, y=10; "yes", "no"} -- Gemischte Tabelle mit t.x, t.y, t[1], t[2]
t = {msg = "choice", {"yes", "no", "?"}} -- Tabellen können ebenfalls Tabellen enthalten.

Zuweisungen

a = 5
b = "hi"
local a = a
-- Einfache Zuweisungen. Variablen sind nicht typisiert und können verschiede 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 = "there" -- 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 - a = 5.
a = 3 .. 2 -- Der Verbindungsoperator erwartet Zeichenketten, die Zahlen werden 
           -- konvertiert - a = "32".

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 sind automatisch nil. Dasselbe gilt für Rückgabewerte. Dadurch lassen sich Funktionsüberladungen einfacher implementieren, das Vorkommen von Laufzeitfehlern steigt jedoch.

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:

 function factorial(n)
   if n == 0 then
      return 1
   else
      return n * factorial(n - 1)
   end
 end

Funktionen gelten in Lua als First-Class-Elemente. Das bedeutet insbesondere, dass Funktionen während der Laufzeit dynamisch erzeugt und verändert werden können. Das folgende Beispiel zeigt die Veränderung der Standardfunktion print:

do
  local oldprint = print   -- Store current print function as oldprint
  function print(s)        -- Redefine print function
    oldprint("I say: " .. s)
  end
end

Befehle in Lua können – müssen aber nicht – am Ende einer Zeile mit einem Semikolon abgeschlossen werden.

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.

Benutzermodule

Lua bietet die Möglichkeit, benutzerdefinierte Module zu erstellen. Für die Verwaltung von Modulen ist der in Lua geschriebene Paketverwalter Luarocks besonders geeignet.

Eine Liste mit verbreiteten Lua-Modulen:

Modul	Beschreibung
LuaFileSystem	Zugriff auf Ordnerstrukturen und Dateieigenschaften.
LuaDoc	Dokumentationstool für Lua-Quellcode.
LuaSocket	Lua Interface für Netzwerkprotokolle: HTTP, FTP, SMTP, MIME, URL und LTN12.
LuaSQL	Lua Interface für PostgreSQL, ODBC, MySQL, SQLite, Oracle, and OLE DB.
stdlib	Bibliothek für häufige Programmieraufgaben, bezieht sich auf Listen, Tabellen, funktionale Programmierung, Regulärer Ausdruck, Objekte, Pretty-Printing und getopt.
MD5	einfache Cryptography-Fähigkeiten für Lua
Copas	Dispatcher basierend auf Coroutinen, welcher von TCP/IP-Servern verwendet werden kann.
LuaZip	Bibliothek welche 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 (Stichwort: CORBA).

Weitere Module können auf der Communityseite Luaforge oder dem Repository von Luarocks gefunden werden.

Verwendung

Lua kann sowohl zur Erstellung eigenständiger Programme verwendet werden als auch als eingebettete Sprache dienen.

Es erfreut sich besonderer Beliebtheit bei Computerspielprogrammierern: 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 in dieser Branche oft zum Einsatz. Dies macht die meist teuer entwickelte Spiel-Engine flexibler und ermöglicht eine mit geringerem Aufwand verbundene Wiederverwendbarkeit. Daher wird Lua im Bereich proprietärer Spiele verwendet.

Anwendung findet Lua aber auch in diversen Standard-Applikationen wie Adobe Photoshop Lightroom, SqueezeBox, Wireshark oder VLC Media Player zur Konfiguration und zur Automatisierung von häufigen Vorgängen.

Literatur

• Roberto Ierusalimschy: Programmieren mit Lua, September 2006, ISBN 3-937514-22-8
• Roberto Ierusalimschy: Lua 5.1 Reference Manual, August 2006, ISBN 85-903798-3-3
• Kurt Jung, Aaron Brown: Beginning Lua Programming, 2007, ISBN 0-470-06917-1
• Paul Schuytema, Mark Manyen: Game Development with Lua, 2005, ISBN 1-58450-404-8

Weblinks

• www.lua.org – Offizielle Website (auf Englisch und Portugiesisch)
• Lua-Kurzreferenz (Englisch) - kompakte Zusammenfassung aller Sprachfeatures.
• Links zum Thema Lua im Open Directory Project

Einzelnachweise

1. ↑ LuaJIT. Abgerufen am 16. Oktober 2011 (englisch). 
2. ↑ LLVM-Lua. Abgerufen am 16. Oktober 2011 (englisch). 
3. ↑ LuaCLR. Abgerufen am 16. Oktober 2011 (englisch). 
4. ↑ Nua (Lua for the DLR). Abgerufen am 16. Oktober 2011 (englisch). 
5. ↑ lua-alchemy. Abgerufen am 16. Oktober 2011 (englisch). 
6. ↑ LuaJIT. Abgerufen am 16. Oktober 2011 (englisch). 
7. ↑ Ein Beispiel für die Definition einer Klasse und die Ableitung von Objekten daraus ist: inequality-1.4.0. (Anwendung: Berechnung von Ungleichverteilungsmaßen für die Wirtschafts- und Sozialwissenschaften). Das Programm ist sowohl in Lua als auch in Python implementiert und ermöglicht dadurch einen Vergleich. Abgerufen am 16. Oktober 2011 (englisch).