imported>Vfb1893: BKL Modula aufgelöst

2025-08-21T19:11:15Z

BKL Modula aufgelöst

Neue Seite

{{Dieser Artikel|behandelt die Programmiersprache. Zu weiteren Bedeutungen siehe [[Lua (Begriffsklärung)]].}}
{{Infobox Programmiersprache
| Name = Lua
| Logo = [[Datei:Lua-Logo.svg|130px|Lua-Logo]]
| Beschreibung = Lua-Logo
| Logo-Hintergrund = 1
| Paradigma = [[Skriptsprache]], [[Imperative Programmierung|imperativ]], [[Funktionale Programmierung|funktional]]
| Erscheinungsjahr = 1993
| Entwickler = Roberto Ierusalimschy,<br />Waldemar Celes,<br />Luiz Henrique de Figueiredo
| AktuelleVersion = 
| AktuelleVersionFreigabeDatum =
| Typisierung = dynamisch, schwach ({{lang|en|weak typing}})
| Implementierung = '''Lua''', LuaJIT<ref name="LuaJIT">{{Internetquelle |url=https://luajit.org/ |titel=LuaJIT |sprache=en |abruf=2017-02-26}}</ref>, LLVM-Lua<ref>{{Internetquelle |url=https://github.com/neopallium/llvm-lua |titel=LLVM-Lua |sprache=en |abruf=2017-02-26}}</ref>, LuaCLR<ref>{{Internetquelle |url=https://github.com/mascarenhas/luaclr |titel=LuaCLR |sprache=en |abruf=2016-01-03}}</ref>
| Dialekte = Metalua, Idle, GSL Shell
| Beeinflusst_von = [[C++]], [[CLU (Programmiersprache)|CLU]], [[Modula-2]], [[Scheme]], [[SNOBOL]]
| Beeinflusste = [[Falcon (Programmiersprache)|Falcon]], [[GameMonkey]], [[Io (Programmiersprache)|Io]], [[JavaScript]], [[Julia (Programmiersprache)|Julia]], [[MiniD]], [[MoonScript]], [[Red (Programmiersprache)|Red]], [[Ruby (Programmiersprache)|Ruby]], [[Squirrel (Programmiersprache)|Squirrel]]
| Standardisierungen =
| Betriebssystem = [[Plattformunabhängigkeit|plattformunabhängig]]
| Lizenz = [[MIT-Lizenz]]
| Website = [https://www.lua.org/ www.lua.org]
}}

'''Lua''' ({{ptS}} für ''[[Mond]]'') ist eine [[Imperative Programmierung|imperative]] und erweiterbare [[Skriptsprache]] zum Einbinden in [[Computerprogramm|Programme]], um diese leichter weiterentwickeln und warten zu können. Eine der besonderen Eigenschaften von Lua ist die geringe Größe des [[Compiler|kompilierten]] Skript-[[Interpreter]]s.

Lua-Programme sind meist [[Plattformunabhängigkeit|plattformunabhängig]] und werden vor der Ausführung in [[Bytecode]] übersetzt. Lua ist vorrangig als eingebettete Skriptsprache für andere Programme konzipiert, aber man kann auch eigenständige Programme schreiben. 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 (Programmiersprache)|C]]-[[Programmbibliothek|Bibliothek]] angesprochen werden, die auch ein [[Programmierschnittstelle|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 [[Just-in-time-Kompilierung|JIT-Compiler]] namens LuaJIT, der die Revision 5.1 der Sprache unterstützt.<ref name="LuaJIT" />

Lua ist in [[Varianten der Programmiersprache C|ANSI-C]] [[Implementierung#Softwaretechnik|implementiert]] und unterstützt imperative und [[Funktionale Programmierung|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äpstliche Katholische Universität von Rio de Janeiro|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 [[Computerspiel]]s wie z. B. Konfigurationsdateien oder die [[Künstliche Intelligenz|KI]] von [[Nicht-Spieler-Charakter|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är]]er Spiele verwendet wird. Lua wird zum Beispiel in dem bekannten Spiel „[[Roblox]]“ verwendet.

Auch einige insbesondere dynamische und [[Tiling (Computer)|Tiling]]-[[Fenstermanager]] nutzen Lua für Konfiguration und Steuerung, darunter [[awesome (Fenstermanager)|awesome]]<ref>Julien Danjou: [https://julien.danjou.info/why-not-lua/ ''Why not Lua''], abgerufen am 19. Juni 2021.</ref> und [[Ion (Fenstermanager)|Ion3]].

== Syntax ==
=== Datentypen ===
Neben den Datentypen [[Nullwert|nil]], [[Boolesche Variable|boolean]], number (mit den internen Subtypen [[Integer (Datentyp)|integer]] und [[Gleitkommazahl|float]]), [[Zeichenkette|string]], function, userdata und [[Koroutine|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 Sprachen, die der [[C (Programmiersprache)|Programmiersprache C]] ähnlich sind, mit 1.

Zu den Tabellen gibt es in Lua auch metatable; diese sind table, die an einem Table gebunden sind. Jedoch kann man nicht einfach auf sie zugreifen, wenn man durch die Tabelle durchläuft. Metatable werden oft dafür verwendet, einen nicht vorhandenen Index des Tables zu liefern, z. B. Table = {[1] = "String", [2] = 13, [5] = true}. In dem Fall fehlt der Index 3 und 4. Wenn jetzt aber ein Metatable daran gebunden ist, können die Indexe 3 und 4 aus diesem verwendet werden. Das verhindert, dass Lua die [[Schleife (Programmierung)|Schleife]] abbricht. Ohne die Metatable würde hier der Index 5 einfach nicht mehr mit gelesen werden. Metatable können mit ''setmetatable()'' bearbeitet und erschaffen werden. Mit ''getmetatable()'' kann die Metatable in einer [[Variable (Programmierung)|Variable]] gespeichert werden.

Tabellen können auf folgende Weisen erzeugt werden:
<syntaxhighlight lang="lua">
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.
</syntaxhighlight>

=== Zuweisungen ===
<syntaxhighlight lang="lua">
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 ...)
</syntaxhighlight>

=== Funktionen ===
Funktionen können mit dem Schlüsselwort <code>function</code> erzeugt werden. Funktionen besitzen keine fixierte Anzahl an Parametern und Rückgabewerten.

<syntaxhighlight lang="lua">
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.
</syntaxhighlight>

Beim Aufruf der Funktion müssen nicht alle Variablen übergeben werden. Fehlende Parameter besitzen automatisch den [[Nullwert]] <code>nil</code>. Dasselbe gilt für Rückgabewerte. Dadurch lassen sich Funktionsüberladungen einfacher implementieren, das Vorkommen von Laufzeitfehlern steigt jedoch.

=== Reservierte Schlüsselwörter ===
<syntaxhighlight lang="text">
and break do else elseif end false for function goto if in
local nil not or repeat return then true until while
</syntaxhighlight>

Das Schlüsselwort <code>nil</code> 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:

<syntaxhighlight lang="lua">
print("Hallo Welt!")
</syntaxhighlight>

[[Kommentar (Programmierung)|Kommentare]] können einzeilig sowie mehrzeilig verfasst werden:

<syntaxhighlight lang="lua">
-- 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.]]
</syntaxhighlight>

Beispiel für eine [[Rekursion]] (Berechnung der [[Fakultät (Mathematik)|Fakultät]]):

<syntaxhighlight lang="lua">
function factorial(n)
if n == 0 then
return 1
end

return n * factorial(n - 1)
end
</syntaxhighlight>

Mit den [[Kurzschlussauswertung|Kurzschlussoperatoren]] „and“ und „or“ kann die Funktion kürzer so geschrieben werden (dies entspricht dem [[Bedingte Anweisung und Verzweigung#Auswahloperator|Auswahloperator]] ?: von [[Programmiersprache C|C]] und verwandten Sprachen):
<syntaxhighlight lang="lua">
function factorial(n)
return n == 0 and 1 or n * factorial(n - 1)
end
</syntaxhighlight>

Funktionen gelten in Lua als [[First-Class-Objekt]]e. 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 <code>print</code> (welche auf eine Standardfunktion der Lua-Bibliothek zeigt) mit einer anderen Funktion überschrieben wird:

<syntaxhighlight lang="lua">
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
</syntaxhighlight>

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 (Programmiersprache)|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:

{| class="wikitable"
|-
! 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]], [[Open Database Connectivity|ODBC]], [[MySQL]], [[SQLite]], [[Oracle]], und [[OLE DB]].
|-
| stdlib || Bibliothek für häufige Programmieraufgaben; bezieht sich auf Listen, Tabellen, funktionale Programmierung, [[Regulärer Ausdruck|Reguläre Ausdrücke]], Objekte, [[Quelltextformatierung|Pretty-Printing]] und getopt.
|-
| [[Message-Digest Algorithm 5|MD5]] || einfache [[kryptografische Hashfunktion]]
|-
| Copas || Dispatcher, basierend auf Co-Routinen, der von [[TCP/IP]]-Servern verwendet werden kann.
|-
| LuaZip || Bibliothek, die von [[ZIP-Dateiformat|ZIP-Dateien]] lesen kann.
|-
| LuaInterface || Verbindung zwischen Lua und [[Microsoft]]s [[.Net-Framework]] [[Common Language Runtime]] (CLR).
|-
| LuaBitOps || Eine auf [[C (Programmiersprache)|C]] basierende Erweiterung für Lua für bitweise Operationen von Zahlen.
|-
| LuaXML || Einfache Verbindung zwischen [[Extensible Markup Language|XML]] und Lua.
|-
| Lanes || Ermöglicht die [[Nebenläufigkeit|parallele Ausführung]] von verschiedenen Lua-Umgebungen.
|-
| Penlight || Bibliothek, die den Umgang mit Tabellen, [[Feld (Datentyp)|Arrays]], Strings, Dateipfaden, Ordnern, Daten und funktionalen Programmieranwendungen vereinfacht.
|-
| Oil || Einfacher und effizienter Object Request Broker ([[Common Object Request Broker Architecture|CORBA]]).
|}

== Literatur ==
* Roberto Ierusalimschy: ''Programmieren in Lua'', 4. Auflage, Open Source Press, 2016, ISBN 978-85-903798-6-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-907857-15-1.
* David Young: ''Learning Game AI Programming with Lua'', Packt Publishing, 2014, ISBN 1-78328-133-2.

== Weblinks ==
{{Commonscat|Lua (programming language)|Lua}}
* [https://www.lua.org/ Lua.org] – offizielle Website (englisch und portugiesisch)
* [https://www.luafaq.org/ Lua Unofficial FAQ]
* [https://luarocks.org/ LuaRocks] – Paketmanager und -repository
* [http://lua-users.org/wiki/ Lua Users Wiki]
* [https://github.com/LewisJEllis/awesome-lua Awesome Lua] auf GitHub
* [http://tylerneylon.com/a/learn-lua/ Learn Lua in 15 Minutes]
* [https://intern.fh-wedel.de/~si/seminare/ws09/Ausarbeitung/09.lua/lua0.htm Schnelles, leichtgewichtiges, eingebettetes Scripting mit Lua] von Jan Bornholdt, [[Fachhochschule Wedel]]

== Quellen und Anmerkungen ==
<references responsive />

{{Normdaten|TYP=s|GND=7547043-3}}

[[Kategorie:Skriptsprache]]
[[Kategorie:Imperative Programmiersprache]]

Lua - Versionsgeschichte

imported>Vfb1893: BKL Modula aufgelöst