Lua

aus Wikipedia, der freien Enzyklopädie
Wechseln zu: Navigation, Suche
Der Titel dieses Artikels ist mehrdeutig. Weitere Bedeutungen sind unter Lua (Begriffsklärung) aufgeführt.
Lua
Lua-Logo
Lua-Logo
Basisdaten
Paradigmen: Skriptsprache, imperativ, funktional, objektorientiert
Erscheinungsjahr: 1993
Entwickler: Roberto Ierusalimschy,
Waldemar Celes,
Luiz Henrique de Figueiredo
Aktuelle Version: 5.2.3  (7. Dezember 2013)
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
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 veröffentlicht, seit Version 5 unter der MIT-Lizenz.

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 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 namens LuaJIT, der die Revision 5.1 der Sprache unterstützt.[6]

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.[7]

Verwendung[Bearbeiten]

Lua kann sowohl zur Erstellung 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.

Beispiele für den Einsatz von Lua[Bearbeiten]

Beispielsweise existiert eine Modifikation für das Java-basierte Computerspiel Minecraft, mit der man im Spiel an einem virtuellen Computer unter Verwendung von Lua programmieren kann.[8][9]

Das auf der Source-Engine basierende Spiel Garry’s Mod ist durch Add-ons erweiterbar die komplett auf Lua basieren.[10]

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

Der Netzwerkscanner nmap verwendet Lua für die Nmap Scripting Engine zum Automatisieren einer Vielzahl von Netzwerkfunktionen.[11]

Der XMPP-Server prosody und seine Add-ons sind komplett in Lua geschrieben.

LuaTeX ist eine Integration von Lua in einen Nachfolger von TeX.[12]

Das im Mai 2012 entdeckte Schadprogramm Flame ist im Kern in Lua geschrieben worden.[13]

Syntax[Bearbeiten]

Datentypen[Bearbeiten]

Neben den Datentypen nil, boolean, number, string, function, userdata und thread kennt Lua – als einzigen strukturierten Datentyp – den 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 = {"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} -- Typisches assoziatives Datenfeld 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[Bearbeiten]

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 = "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, also erfolgt hier die Zuweisung a = 5.
a = 3 .. 2 -- Der Verbindungsoperator erwartet Zeichenketten, die Zahlen werden 
           -- konvertiert - a = "32".

Funktionen[Bearbeiten]

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[Bearbeiten]

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 für eine nicht initialisierte Variable.

Beispielcode[Bearbeiten]

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

Verkürzt mit dem "and or" Operator:

 function factorial(n)
   return (n==0) and 1 or n * factorial(n - 1)
 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 mit einem Semikolon abgeschlossen werden. Falls in Ausnahmefällen 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, sowie „=“ als Zuweisungsoperator (anstelle von „:=“ in Pascal).

Module[Bearbeiten]

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 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).

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

Literatur[Bearbeiten]

Weblinks[Bearbeiten]

Einzelnachweise[Bearbeiten]

  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).
  8. ComputerCraft im Minecraft Forum. Abgerufen am 2. März 2012.
  9. Offizielle Seite von ComputerCraft. Abgerufen am 2. März 2012.
  10. Garry's Mod Lua Tutorials. Abgerufen am 4. Juli 2014 (englisch).
  11. Nmap Scripting Engine - Introduction. Abgerufen am 8. Dezember 2011 (englisch).
  12. LuaTeX. Abgerufen am 20. Februar 2012.
  13. FAZ_Flame. Abgerufen am 23. Oktober 2012.