Lua (Programmiersprache)

Lua

Paradigma	Multi-Paradigma: Scripting, Imperativ (prozedural, Prototypbasiert, objektorientierter), funktional, Meta, reflektierend
Entworfen von	Roberto Ierusalimschy Waldemar Celes Luiz Henrique de FigueiReiedo
Erstmals erschienen	1993; Vor 29 Jahren
Stabile Version	5.4.4[1]  / 26. Januar 2022; vor 6 Monaten
Disziplin tippen	Dynamisch, stark, Ente
Implementierungssprache	Ansi c
OS	Plattformübergreifend
Lizenz	MIT -Lizenz
Dateiname -Erweiterungen	.lua
Webseite	www.lua.org
Haupt Implementierungen
Lua, Luajit, LuavelaAnwesendMondsharp, Liebe es, Luart, Luau
Dialekte
Metalua, Leerlauf, GSL Shell
Beeinflusst von
C ++, Clu, Modula, Planen, Snobol
Beeinflusst
Gamemonkey, Io, JavaScript, Julia, Minid, Rot, Ring,[2] Rubin, Eichhörnchen, Moonscript, C--

Lua (/ˈluːə/ KLO-ə; aus Portugiesisch: lua [ˈLu. (W) ɐ] Bedeutung Mond) ist ein Leicht, hohes Level, Multi-Paradigm-Programmiersprache in erster Linie für Einbettungsgebrauch in Anwendungen.^[3] Lua ist plattformübergreifend, seit der Dolmetscher von zusammengestellt Bytecode ist geschrieben Ansi c,^[4] und Lua hat ein relativ einfaches c API um es in Anwendungen einzubetten.^[5]

Lua wurde ursprünglich 1993 als Sprache für die Ausdehnung entworfen Softwareanwendungen um die zunehmende Nachfrage nach Anpassungsanpassungen zu diesem Zeitpunkt zu befriedigen. Es lieferte die grundlegenden Einrichtungen der meisten Verfahrensprogrammierung Sprachen, aber komplizierter oder Domänenspezifisch Merkmale waren nicht enthalten; Es enthielt vielmehr Mechanismen zur Erweiterung der Sprache und ermöglichten es den Programmierern, solche Funktionen zu implementieren. Da Lua eine allgemeine eingebettete Erweiterungssprache sein sollte, konzentrierten sich die Designer von Lua auf die Verbesserung der ihr Geschwindigkeit, Portabilität, Erweiterbarkeit und Benutzerfreundlichkeit in der Entwicklung.

Geschichte

Lua wurde 1993 von geschaffen von Roberto Ierusalimschy, Luiz Henrique de FigueiReiedo und Waldemar Celes, Mitglieder der Computer Graphics Technology Group (TECGRAF) Päpstliche katholische Universität von Rio de Janeiro, in Brasilien.

Von 1977 bis 1992 hatte Brasilien eine starke Politik Handelsbarrieren (Marktreserve genannt) für Computerhardware und Software. In dieser Atmosphäre konnten sich die Kunden von Tecgraf weder politisch noch finanziell maßgeschneiderte Software aus dem Ausland kaufen. Diese Gründe veranlassten TECGRAF, die grundlegenden Tools von Grund auf neu zu implementieren.^[6]

Die Vorgänger von Lua waren die Datendeskriptions-/Konfigurationssprachen SOL (Einfache Objektsprache) und Del (Dateneintrittssprache).^[7] Sie wurden in den Jahren 1992 bis 1993 bei TECGRAF unabhängig voneinander entwickelt, um zwei verschiedene Projekte Flexibilität zu verleihen (beide waren interaktive grafische Programme für technische Anwendungen bei Petrobras Gesellschaft). In SOL und DEL mangelte es an Strömungs-Kontroll-Strukturen, und Petrobras war der Ansicht, dass sie wachsend mussten, eine vollständige Programmierleistung zu verleihen.

Im Die Entwicklung von Lua, Die Autoren der Sprache haben geschrieben:^[6]

1993 war der einzige wirkliche Anwärter Tcl, die ausdrücklich so konzipiert worden war, dass sie in Anwendungen eingebettet werden. TCL hatte jedoch eine unbekannte Syntax, bot keine gute Unterstützung für die Datenbeschreibung und lief nur auf UNIX -Plattformen. Wir haben nicht in Betracht gezogen LISPELN oder Planen wegen ihrer unfreundlichen Syntax. Python war noch in den Kinderschuhen. In der freien, do-it-yourself-Atmosphäre, die dann in Tecgraf regierte, war es ganz natürlich, dass wir versuchen sollten, unsere eigene Skriptsprache zu entwickeln ... weil viele potenzielle Benutzer der Sprache keine professionellen Programmierer waren, sollte die Sprache kryptisch vermieden werden Syntax und Semantik. Die Implementierung der neuen Sprache sollte sehr tragbar sein, da die Kunden von Tecgraf eine sehr vielfältige Sammlung von Computerplattformen hatten. Da wir erwartet hatten, dass andere TECGRAF -Produkte ebenfalls eine Skriptsprache einbetten müssen, sollte die neue Sprache dem Beispiel von SOL folgen und als Bibliothek mit einer C -API zur Verfügung gestellt werden.

LUA 1.0 wurde so konzipiert, dass sich die Objektkonstruktoren, die sich dann geringfügig vom aktuellen Licht und flexiblen Stil unterschieden hatten, die Datendesschreibungssyntax von SOL integrierte (daher der Name Lua: Sol bedeutet "Sonne" auf Portugiesisch, und Lua bedeutet "Mond"). Lua Syntax Für Kontrollstrukturen wurde größtenteils von entlehnt von Modula (wenn, während, wiederholen/bis um), aber auch Einfluss von Clu (Mehrere Zuordnungen und mehrere Rückgaben von Funktionsaufrufen als einfachere Alternative zu Referenzparameter oder explizit Zeiger), C ++ ("Nette Idee, a zuzulassen lokale Variable Nur dort deklariert zu werden, wo wir es brauchen "^[6]), Snobol und Awk (assoziative Arrays). In einem Artikel veröffentlicht in Dr. Dobbs Journal, Luas Schöpfer geben auch an, dass Lisp und Schema mit ihrem allgegenwärtigen Datenstrukturmechanismus (der aufführen) waren ein wesentlicher Einfluss auf ihre Entscheidung, die Tabelle als primäre Datenstruktur der LUA zu entwickeln.^[8]

Lua Semantik wurden im Laufe der Zeit zunehmend vom Schema beeinflusst,^[6] vor allem mit der Einführung von Anonyme Funktionen und voll lexikaler Scoping. In neuen Lua -Versionen wurden mehrere Funktionen hinzugefügt.

Versionen von LuA vor Version 5.0 wurden unter einer ähnlichen Lizenz wie dem veröffentlicht BSD -Lizenz. Ab Version 5.0 wurde Lua unter dem lizenziert MIT -Lizenz. Beide sind zulässige kostenlose Softwarelizenzen und sind fast identisch.

Merkmale

Lua wird allgemein als "beschrieben" beschrieben "Multi-Paradigma"Sprache, die eine kleine Reihe allgemeiner Merkmale bereitstellt, die auf verschiedene Problemtypen anpassen können. LUA enthält keine explizite Unterstützung für Nachlass, aber erlaubt es mit implementiert mit Einfuhrables. In ähnlicher Weise ermöglicht Lua Programmierer implementieren Namespaces, Klassenund andere verwandte Merkmale unter Verwendung der Implementierung der einzelnen Tabellen; erstklassige Funktionen Ermöglichen Sie den Einsatz vieler Techniken von Funktionelle Programmierung; und voll lexikaler Scoping feinkörnig Informationen verstecken sich die Durchsetzung der Prinzip der geringsten Privilegien.

Im Allgemeinen bemüht sich Lua, einfache, flexible zu liefern Meta-Featuren Dies kann bei Bedarf erweitert werden, anstatt ein spezifisches Feature-Set für ein Programmierparadigma zu liefern. Infolgedessen ist die Basissprache hell- Die vollständige Referenz Dolmetscher ist nur ungefähr 247KB zusammengestellt^[4]- und leicht an eine breite Palette von Anwendungen anpassen.

A dynamisch getippt Sprache, die für die Verwendung als Erweiterungssprache bestimmt ist oder SkriptspracheLUA ist kompakt genug, um auf eine Vielzahl von Hostplattformen zu passen. Es unterstützt nur eine kleine Anzahl von Atomdatenstrukturen wie z. Boolesche Werte, Zahlen (doppelte Präzision schwimmender Punkt und 64-Bit Ganzzahlen standardmäßig) und Saiten. Typische Datenstrukturen wie z. Arrays, Sets, Listen, und Aufzeichnungen kann unter Verwendung der einzelnen nativen Datenstruktur von Lua dargestellt werden, die Tabelle, die im Wesentlichen heterogen ist Assoziatives Array.

Lua implementiert eine kleine Reihe fortschrittlicher Funktionen wie z. erstklassige Funktionen, Müllsammlung, Schließungen, richtig Schwanzaufrufe, Zwang (Automatische Konvertierung zwischen String- und Zahlenwerten zur Laufzeit), Coroutinen (kooperative Multitasking) und Dynamisches Modulbelastung.

Syntax

Der Klassiker "Hallo Welt!" Programm kann wie folgt geschrieben werden:^[9]

drucken("Hallo Welt!") 

oder wie:

drucken 'Hallo Welt!' 

A Kommentar in lua beginnt mit einem doppelhyphen und rennt bis zum Ende der Linie, ähnlich wie Ada, Eiffel, Haskell, Sql und VHDL. Multi-Line-Saiten und Kommentare sind mit zwei Quadratklammern geschmückt.

Das Fakultät Die Funktion wird in diesem Beispiel als Funktion implementiert:

Funktion Fakultät(n)  lokal x = 1  zum i = 2, n tun  x = x * i  Ende  Rückkehr x Ende 

Steuerfluss

Lua hat eine Art von Art von bedingt Prüfung: Wenn dann enden mit optional anders und sonst dann Ausführungssteuerungskonstrukte.

Das generische Wenn dann enden Die Anweisung erfordert alle drei Schlüsselwörter:

wenn Bedingung dann 	-Statement Körper Ende 

Das anders Das Schlüsselwort kann mit einem begleitenden Anweisungsblock hinzugefügt werden, um die Ausführung zu steuern, wenn die wenn Bedingung bewertet FALSCH:

wenn Bedingung dann 	-Statement Körper anders 	-Statement Körper Ende 

Die Ausführung kann auch gemäß mehreren Bedingungen unter Verwendung der kontrolliert werden sonst dann Schlüsselwörter:

wenn Bedingung dann 	-Statement Körper elseif Bedingung dann 	-Statement Körper anders -- Optional 	-optional Standard Statement-Körperschaft Ende 

Lua hat vier Arten von bedingten Schleifen: die während Schleife, das wiederholen Schleife (ähnlich a tu während Schleife) der numerische zum Schleifeund der generische zum Schleife.

-Edition = true während Bedingung tun  -Statements Ende wiederholen  -Statements bis um Bedingung zum i = Erste, letzte, Delta tun  -Delta kann negativ sein, sodass die für die Schleife abzählt oder hochgezogen werden kann  -Statements  -Beispiel: Print (i) Ende 

Das generische zum Schleife:

zum Schlüssel, Wert in Paare(_G) tun  drucken(Schlüssel, Wert) Ende 

würde über den Tisch iterieren _G Verwenden der Standard -Iteratorfunktion Paare, bis es zurückkehrt Null.

Loops können auch sein verschachtelt (Innen in einer anderen Schleife setzen).

lokal Netz = {  { 11, 12, 13 },  { 21, 22, 23 },  { 31, 32, 33 } } zum y, die Zeile in Ipairs(Netz) tun  zum x, Wert in Ipairs(die Zeile) tun  drucken(x, y, Wert)  Ende Ende 

Funktionen

Luas Behandlung von Funktionen als erste Klasse Werte werden im folgenden Beispiel angezeigt, wobei das Verhalten der Druckfunktion geändert wird:

tun  lokal Oldprint = drucken  - Speichern Sie die aktuelle Druckfunktion als Oldprint  Funktion drucken(s)  -[[Druckfunktion neu definieren. Die übliche Druckfunktion kann weiterhin verwendet werden       Durch Oldprint. Der neue hat nur ein Argument.]]]  Oldprint(s == "Foo" und "Bar" oder s)  Ende Ende 

Jede zukünftige Anrufe zu drucken wird nun durch die neue Funktion und wegen Lua's geleitet lexikaler ScopingDie alte Druckfunktion ist nur vom neuen, geänderten Druck zugänglich.

Lua unterstützt auch Schließungen, wie unten gezeigt:

Funktion ergänzen(x)  - Geben Sie eine neue Funktion zurück, die X zum Argument hinzufügt  Rückkehr Funktion(y)  -[= [Wenn wir uns auf die Variable x beziehen, die außerhalb des Stroms liegt       Umfang und deren Leben wäre kürzer als das dieses Anonymos       Funktion schafft Lua einen Verschluss.] =]  Rückkehr x + y  Ende Ende vierplus = ergänzen(4) drucken(vierplus(3))  - Drucke 7 -Dies kann auch erreicht werden, indem die Funktion auf folgende Weise aufgerufen wird: drucken(ergänzen(4) (3)) -[[Dies liegt daran, dass wir die zurückgegebene Funktion von 'AddTo (4)' mit dem Argument '3' direkt aufrufen.   Dies hilft auch, die Datenkosten und die Leistung zu senken, wenn sie iterativ aufgerufen werden. ]] 

Eine neue Schließung für die Variable x wird jedes Mal erstellt ergänzen wird aufgerufen, so dass jede neue anonyme Funktion zurückgegeben wird x Parameter. Die Schließung wird von Luas Müllsammler verwaltet, genau wie jedes andere Objekt.

Tische

Tabellen sind die wichtigsten Datenstrukturen (und entworfen die einzigen integrierten zusammengesetzter Datentyp) in Lua und sind die Grundlage aller vom Benutzer erstellten Typen. Sie sind assoziative Arrays mit dem automatischen numerischen Schlüssel und einer speziellen Syntax.

Eine Tabelle ist eine Sammlung von Schlüssel- und Datenpaaren, wobei die Daten nach Schlüssel verwiesen werden. Mit anderen Worten, es ist a Hashed Heterogenes assoziatives Array.

Tabellen werden mit dem erstellt {} Konstruktorsyntax.

ein Tisch = {} - Erstellt einen neuen, leeren Tisch 

Tabellen werden immer mit Referenz übergeben (siehe Rufen Sie an, indem Sie teilen).

Ein Schlüssel (Index) kann ein beliebiger Wert sein, außer dass Null und Nan, einschließlich Funktionen.

ein Tisch = {x = 10}  - Erstellt eine neue Tabelle mit einer Eintragszuordnung "x" auf die Nummer 10. drucken(ein Tisch["x"])) - druckt den Wert, der dem String-Schlüssel zugeordnet ist, in diesem Fall 10. B_TABLE = ein Tisch B_TABLE["x"] = 20  - Der Wert in der Tabelle wurde auf 20 geändert. drucken(B_TABLE["x"])) - Drucke 20. drucken(ein Tisch["x"])) - Auch 20 druckt 20, weil A_Table und B_Table beide auf dieselbe Tabelle beziehen. 

Eine Tabelle wird oft als verwendet als Struktur (oder Aufzeichnung) durch die Nutzung Saiten als Schlüssel. Da eine solche Verwendung sehr häufig ist, verfügt die Lua mit einer speziellen Syntax für den Zugriff auf solche Felder.^[10]

Punkt = { x = 10, y = 20 }  - Neue Tabelle erstellen drucken(Punkt["x"]))  - Drucke 10 drucken(Punkt.x)  - hat genau die gleiche Bedeutung wie die Zeile oben. Die leichter zu lesende Punktnotation ist nur syntaktischer Zucker. 

Durch die Verwendung einer Tabelle zum Speichern verwandter Funktionen kann sie als Namespace fungieren.

Punkt = {} Punkt.Neu = Funktion(x, y)  Rückkehr {x = x, y = y}  - return {["x"] = x, ["y"] = y} Ende Punkt.set_x = Funktion(Punkt, x)  Punkt.x = x  - Punkt ["x"] = x; Ende 

In den Tabellen wird automatisch ein numerischer Schlüssel zugewiesen, sodass sie als verwendet werden können Array -Datentyp. Der erste automatische Index ist eher 1 als 0, da er für viele andere Programmiersprachen ist (obwohl ein explizite Index von 0 zulässig ist).

Ein numerischer Schlüssel 1 unterscheidet sich von einem String -Schlüssel "1".

Array = { "a", "b", "c", "d" }  - Indizes werden automatisch zugewiesen. drucken(Array[2]))  - Drucke "B". Die automatische Indizierung in Lua beginnt bei 1. drucken(#Array)  - Drucke 4. # ist der Länge Operator für Tische und Zeichenfolgen. Array[0] = "Z"  - Null ist ein legaler Index. drucken(#Array)  -Drucken noch 4, da die LUA-Arrays 1 basiert. 

Die Länge eines Tisches t ist definiert als ein ganzzahliger Index n so dass T [n] ist nicht Null und t [n+1] ist Null; Außerdem, wenn T [1] ist Null, n Kann Null sein. Für ein reguläres Array mit Nicht-Nil-Werten von 1 bis zu einem gegebenen n, seine Länge ist genau das n, der Index seines letzten Wertes. Wenn das Array "Löcher" hat (dh, nil-Werte zwischen anderen Nicht-Nil-Werten), dann dann #t Kann eines der Indizes sein, die direkt a vorausgehen a Null Wert (dh kann es einen solchen Nullwert als Ende des Arrays betrachten).^[11]

Prüfbar = {  {1, 2, 3, 4},  {5, 6, 7, 8} } drucken(Prüfbar[1][3])) - Drucke "3" drucken(Prüfbar[2][4])) - Drucke "8" 

Eine Tabelle kann eine Reihe von Objekten sein.

Funktion Punkt(x, y)  - "Punkt" -Objektkonstruktor  Rückkehr { x = x, y = y }  - Erstellt und gibt ein neues Objekt zurück (Tabelle) Ende Array = { Punkt(10, 20), Punkt(30, 40), Punkt(50, 60) }  - Erstellt eine Reihe von Punkten  - array = {{x = 10, y = 20}, {x = 30, y = 40}, {x = 50, y = 60}}; drucken(Array[2].y)  - Drucke 40 

Die Verwendung einer Hash -Karte zur Emulierung eines Arrays ist normalerweise langsamer als die Verwendung eines tatsächlichen Arrays. LUA -Tabellen sind jedoch für die Verwendung als Arrays optimiert, um dieses Problem zu vermeiden.^[12]

Einfuhrables

Erweiterbare Semantik ist ein wichtiges Merkmal von Lua und der wesentlich Das Konzept ermöglicht eine leistungsstarke Anpassung von Tabellen. Das folgende Beispiel zeigt eine "unendliche" Tabelle. Für jeden n, Fibs [n] wird das geben n-Th Fibonacci -Nummer Verwendung Dynamische Programmierung und Memoisierung.

Fibs = { 1, 1 }  - Anfangswerte für Fibs [1] und Fibs [2]. setMetatable(Fibs, {  __Index = Funktion(Werte, n)  -[__ Index ist eine von lua vordefinierte Funktion,                                                     Es wird genannt, wenn Schlüssel "n" nicht existiert.]]  Werte[n] = Werte[n - 1] + Werte[n - 2]  - Berechnen und memoisieren Sie Fibs [n].  Rückkehr Werte[n]  Ende }) 

Objekt orientierte Programmierung

Obwohl Lua kein integriertes Konzept von hat Klassen, Objekt orientierte Programmierung kann mit Funktionen und Tabellen emuliert werden. Ein Objekt wird gebildet, indem Methoden und Felder in eine Tabelle gestellt werden. Nachlass (Sowohl Einzel- als auch mehrere) können mit implementiert werden mit Einfuhrables, delegieren Sie nicht vorhandene Methoden und Felder an ein übergeordnetes Objekt.

Es gibt kein Konzept wie "Klasse" mit diesen Techniken; eher, Prototypen werden verwendet, ähnlich wie Selbst oder JavaScript. Neue Objekte werden entweder mit a erstellt Fabrikmethode (Das konstruiert neue Objekte von Grund auf neu) oder durch Klonen eines vorhandenen Objekts.

Ein grundlegendes Erstellen Vektor Objekt:

lokal Vektor = {} lokal Vectormeta = { __Index = Vektor} Funktion Vektor.Neu(x, y, z)  - Der Konstruktor  Rückkehr setMetatable({{x = x, y = y, z = z}, Vectormeta) Ende Funktion Vektor.Größe(selbst)  -- Eine andere Methode  Rückkehr math.sqrt(selbst.x^2 + selbst.y^2 + selbst.z^2) Ende lokal vec = Vektor.Neu(0, 1, 0) - Erstellen Sie einen Vektor drucken(vec.Größe(vec))  - Rufen Sie eine Methode auf (Ausgabe: 1) drucken(vec.x)  - Zugriff auf eine Mitgliedsvariable (Ausgabe: 0) 

Hier, setmetatable fordert Lua an, nach einem Element in der zu suchen Vector Tabelle, wenn es nicht in der vorhanden ist vec Tisch. vec.magnitude, was gleichbedeutend mit vec["magnitude"], schaut zuerst in die vec Tabelle für die magnitude Element. Das vec Tabelle hat keine magnitude Element, aber seine topferbaren Delegierten an die Vector Tabelle für die magnitude Element, wenn es nicht in der gefunden wird vec Tisch.

Lua liefert einige syntethischer Zucker die Objektorientierung zu erleichtern. Verkünden Mitgliedsfunktionen In einer Prototypentabelle kann man verwenden function table:func(args), was gleichbedeutend mit function table.func(self, args). Aufrufen von Klassenmethoden nutzen auch den Dickdarm: object:func(args) ist äquivalent zu object.func(object, args).

Dies ist hier eine entsprechende Klasse mit : syntethischer Zucker:

lokal Vektor = {} Vektor.__Index = Vektor Funktion Vektor:Neu(x, y, z)  - Der Konstruktor  - Da die Funktionsdefinition einen Dickdarm verwendet,   - Sein erstes Argument ist "Selbst", das sich bezieht  - zu "Vektor"  Rückkehr setMetatable({{x = x, y = y, z = z}, selbst) Ende Funktion Vektor:Größe()  -- Eine andere Methode  - Verweisen Sie auf das implizite Objekt mit Selbst  Rückkehr math.sqrt(selbst.x^2 + selbst.y^2 + selbst.z^2) Ende lokal vec = Vektor:Neu(0, 1, 0) - Erstellen Sie einen Vektor drucken(vec:Größe())  - Rufen Sie eine Methode auf (Ausgabe: 1) drucken(vec.x)  - Zugriff auf eine Mitgliedsvariable (Ausgabe: 0) 

Nachlass

LuA unterstützt die Verwendung von Tunkenstücken, um die Erbschaft der Lua -Klasse zu verleihen.^[13] In diesem Beispiel erlauben wir Vektoren, dass ihre Werte in einer abgeleiteten Klasse mit einer Konstante multipliziert werden.

lokal Vektor = {} Vektor.__Index = Vektor Funktion Vektor:Neu(x, y, z)  - Der Konstruktor  - Hier bezieht sich Selbst auf die "Neue" der Klasse der Klasse  - Methode, die wir nennen. In einer abgeleiteten Klasse wird Selbst  - Sei die abgeleitete Klasse; in der Vektorklasse Selbst  - wird Vektor sein  Rückkehr setMetatable({{x = x, y = y, z = z}, selbst) Ende Funktion Vektor:Größe()  -- Eine andere Methode  - Verweisen Sie auf das implizite Objekt mit Selbst  Rückkehr math.sqrt(selbst.x^2 + selbst.y^2 + selbst.z^2) Ende - Beispiel des Unterrichtsvererbung lokal Vectormult = {} Vectormult.__Index = Vectormult setMetatable(Vectormult, Vektor) - Vectormult zu einem Vektorkind machen Funktion Vectormult:multiplizieren(Wert)   selbst.x = selbst.x * Wert  selbst.y = selbst.y * Wert  selbst.z = selbst.z * Wert  Rückkehr selbst Ende lokal vec = Vectormult:Neu(0, 1, 0) - Erstellen Sie einen Vektor drucken(vec:Größe())  - Rufen Sie eine Methode auf (Ausgabe: 1) drucken(vec.y)  - Zugriff auf eine Mitgliedsvariable (Ausgabe: 1) vec:multiplizieren(2)  - Multiplizieren Sie alle Komponenten des Vektors mit 2 drucken(vec.y)  - NOCH AUFFEHRENE MITGLIEDER (Ausgabe: 2) 

Lua unterstützt auch Mehrfacherbe; __index kann entweder eine Funktion oder eine Tabelle sein.^[14] Bedienerüberlastung kann auch getan werden; Lua -Einfächer können Elemente wie z. __add, __sub, usw.^[15]

Implementierung

LUA -Programme sind nicht interpretiert direkt aus der Text -lua -Datei, aber sind zusammengestellt in Bytecode, das dann auf der Lua ausgeführt wird virtuelle Maschine. Der Zusammenstellungsprozess ist für den Benutzer in der Regel unsichtbar und wird während Laufzeit, besonders wenn a JIT -Compiler wird verwendet, kann aber offline durchgeführt werden, um die Ladeleistung zu erhöhen oder den Speicherpflichtiger der Hostumgebung zu verringern, indem der Compiler ausgelassen wird. Lua -Bytecode kann auch aus der LUA produziert und ausgeführt werden, wobei die entsorgen Funktion aus der String -Bibliothek und der Lade-/Laststring/Lastdatei Funktionen. Die Lua -Version 5.3.4 wird in ungefähr 24.000 Zeilen C -Code implementiert.^[3][4]

Wie die meisten CPUs und im Gegensatz zu den meisten virtuellen Maschinen (die sind Stackbasiert), die lua vm ist Registerbasiertund ähnelt daher eher einem tatsächlichen Hardwaredesign. Die Registerarchitektur vermeidet beide übermäßiges Kopieren von Werten und verringert die Gesamtzahl der Anweisungen pro Funktion. Die virtuelle Maschine von Lua 5 ist eines der ersten registrierenden reinen VMs, die eine große Verwendung erhalten.^[16] Papagei und Android's Dalvik sind zwei weitere bekannte registrierende VMs. Die VM von PCScheme wurde ebenfalls registriert.^[17]

Dieses Beispiel ist die Bytecode -Auflistung der faktoriellen Funktion definiert Oben (wie die von der gezeigt Luac 5.1 Compiler):^[18]

Funktion <factorial.lua: 1,7> (9 Anweisungen, 36 Bytes bei 0x8063c60) 1 Param, 6 Slots, 0 Upvalues, 6 Einheimische, 2 Konstanten, 0 Funktionen 1 [2] Loadk 1 -1; 1 2 [3] Loadk 2 -2; 2 3 [3] Bewegung 3 0 4 [3] Loadk 4 -1; 1 5 [3] FORPREP 2 1; bis 7 6 [4] Mul 1 1 5 7 [3] Forloop 2 -2; bis 6 8 [6] Rückgabe 1 2 9 [7] Return 0 1

C API

Lua soll in andere Anwendungen eingebettet werden und bietet a C API für diesen Zweck. Die API ist in zwei Teile unterteilt: den Lua -Kern und die Lua -Auxiliary -Bibliothek.^[19] Das Design der Lua API beseitigt die Bedarf an Handbuch Referenzverwaltung im C -Code, im Gegensatz zu PythonAPI. Die API ist wie die Sprache minimalistisch. Fortgeschrittene Funktionalität wird von der Auxiliary Library bereitgestellt, die weitgehend besteht Präprozessor Makros die bei komplexen Tischvorgängen helfen.

Die Lua c api ist Stapel basierend. LUA bietet Funktionen zum Schieben und Pop -C -Datentypen (Ganzzahlen, Schwimmer usw.) zum und vom Stapel sowie Funktionen zum Manipulieren von Tabellen durch den Stapel. Der Lua -Stack unterscheidet sich etwas von einem traditionellen Stapel. Der Stapel kann beispielsweise direkt indiziert werden. Negative Indizes geben Offsets von der Oberseite des Stapels an. Zum Beispiel ist –1 der obere (zuletzt gedrückte Wert), während positive Indizes Offsets von unten (ältester Wert) angeben. Marshalle Daten zwischen C- und LUA -Funktionen erfolgen ebenfalls mit dem Stapel. Um eine Lua -Funktion aufzurufen, werden Argumente auf den Stapel gedrückt, und dann die lua_call wird verwendet, um die tatsächliche Funktion aufzurufen. Beim Schreiben einer C -Funktion, die direkt aus Lua aufgerufen werden soll, werden die Argumente aus dem Stapel gelesen.

Hier ist ein Beispiel für das Aufrufen einer Lua -Funktion von C:

#enthalten  #enthalten  // Lua Hauptbibliothek (lua_*) #enthalten  // Lua Auxiliary Library (lual_*) int hauptsächlich(Leere) {   // Erstellen Sie einen Lua -Staat   lua_state *L = lual_newstate();   // eine Zeichenfolge laden und ausführen   wenn (lual_dostring(L, "Funktion foo (x, y) return x+y End")) {   lua_close(L);   Rückkehr -1;   }   // Wert des globalen "Foo" (die oben definierte Funktion)   // zum Stapel, gefolgt von Ganzzahlen 5 und 3   lua_getglobal(L, "Foo");   lua_pushinterger(L, 5);   lua_pushinterger(L, 3);   lua_call(L, 2, 1); // Rufen Sie eine Funktion mit zwei Argumenten und einem Rückgabewert auf   printf("Ergebnis: %d\n", lua_tointeger(L, -1)); // Ganzzahlwert des Elements bei Stack Top drucken   lua_pop(L, 1); // Stapel in den ursprünglichen Zustand zurückgeben   lua_close(L); // LUA State schließen   Rückkehr 0; } 

Ausführen dieses Beispiels gibt:

$ cc -o Beispiel Beispiel.c -lua $ ./example Ergebnis: 8

Die C API bietet auch einige spezielle Tische, die sich in verschiedenen "Pseudo-Indizes" im Lua-Stack befinden. Bei Lua_globalsindex vor lua 5.2^[20] ist die Globals Tabelle, _G von innerhalb von Lua, das ist das Haupt Namespace. Es gibt auch ein Register unter Lua_registryIndex wobei C -Programme LUA -Werte für späteres Abrufen speichern können.

Es ist möglich, Erweiterungsmodule mit der LuA -API zu schreiben. Erweiterungsmodule sind gemeinsame Objekte Dies kann verwendet werden, um die Funktionalität des Dolmetschers zu erweitern, indem LUA -Skripte native Einrichtungen bereitgestellt werden. LUA -Skripte können Erweiterungsmodule verwenden benötigen,^[19] Genau wie Module, die in Lua selbst geschrieben sind, oder mit package.loadlib.^[21] Wenn eine C -Bibliothek über geladen wird erfordern ("foo") Lua wird nach der Funktion suchen luaopen_foo und nennen Sie es, das als jede von Lua abgerufene C -Funktion fungiert und im Allgemeinen eine mit Methoden gefüllte Tabelle zurückgibt. Eine wachsende Sammlung von Modulen, die als bekannt als Felsen sind über a erhältlich Paketverwaltungssystem genannt Luarocks,^[22] im Geist von CPAN, Rubygemems und Python -Eier. Vorgeordnetes Lua Bindungen existieren für die meisten beliebten Programmiersprachen, einschließlich anderer Skriptsprachen.^[23] Für C ++ gibt es eine Reihe von vorlagenbasierten Ansätzen und einige automatische Bindungsgeneratoren.

Anwendungen

Im Videospielentwicklung, Lua wird weit verbreitet als Skriptsprache durch Programmiererhauptsächlich aufgrund seiner wahrgenommenen Leichtigkeit, sich einzubetten, schnell auszuführen und kurz Lernkurve.^[24] Bemerkenswerte Spiele, die LUA verwenden Roblox,^[25] Garrys Mod, Zahltag 2, Phantasy Star Online 2, Dota 2, Angry Birds Space,^[26] Crysis,^[27] und viele andere. Einige Spiele, die die LUA -Programmierung oder -Schripten nicht nativ unterstützen, haben diese Funktionalität durch Mods hinzugefügt, wie z. Computercraft tut für Minecraft. Darüber hinaus wird Lua auch in der Nicht-Video-Spielsoftware verwendet, wie z. Adobe Lightroom, Moho, iClone, Aerospike und bestimmte Systemsoftware in Freebsd und Netbsdund wird als Vorlagen -Skriptsprache auf verwendet Mediawiki Verwenden der Skribunto -Erweiterung.^[28]

Im Jahr 2003 zeigte eine Umfrage von gameDev.net, dass Lua die beliebteste Skriptsprache für die Spielprogrammierung war.^[29] Am 12. Januar 2012 wurde Lua vom Magazin als Gewinner des Front Line Award 2011 bekannt gegeben Spielentwickler In den Kategorie -Programmierwerkzeugen.^[30]

Eine große Anzahl von Nicht-Spielen-Anwendungen verwenden auch LUA zur Erweiterbarkeit, wie z. Luatexeine Umsetzung der Tex Sprache Typ-Setting, Redis, a Schlüsselwertdatenbank, Neovim, ein Texteditor, Nginx, a Webserver, und Wireshark, ein Netzwerkpaketanalysator.

Über die Skribunto-Erweiterung ist Lua als serverseitige Skriptsprache in der verfügbar Mediawiki Software, die versorgt Wikipedia und andere Wikis.^[31] Unter seinen Verwendungen ermöglichen die Integration von Daten von Wikidata in Artikel,^[32] und Stromversorgung des automatisierten Taxobox -Systems.

Abgeleitete Sprachen

Sprachen, die zu Lua zusammenstellen

• Moonscript ist a dynamisch, Whitespace-empfindlich Skriptsprache inspiriert von CoffeeScript, was in Lua zusammengestellt wird. Dies bedeutet, dass anstatt zu verwenden, anstatt zu verwenden tun und Ende (oder { und }), um die verwendeten Codeabschnitte abzugrenzen Zeilenumbrüche und Eindrückstil.^[33][34][35] Eine bemerkenswerte Verwendung von Moonscript ist eine Website für Videospielverteilung Itch.io.
• Haxe Unterstützt die Zusammenstellung eines Lua-Ziels, das LUA 5.1-5.3 sowie unterstützt Luajit 2.0 und 2.1.
• Fenchel, ein Lisp -Dialekt, der auf Lua abzielt.^[35]
• Urne, a Lispeln Dialekt, der auf Lua aufgebaut ist.^[36]
• Amulett, an Ml-wie funktionale Sprache, dessen Compiler Lua -Dateien ausgibt.^[37]

Dialekte

• Luajit
• Luau von Roblox, Lua 5.1 Sprache mit schrittweise Typisierung und ergonomische Ergänzungen.^[38]
• Ravi, JIT-fähige Lua 5.3-Sprache mit optionaler statischer Typisierung. JIT wird nach Typinformationen geleitet.^[39]
• Glänzen, eine Gabel von Luajit mit vielen Erweiterungen, einschließlich eines Modulsystems und eines Makrosystems.^[40]

Darüber hinaus bietet die Community der Lua -Nutzer einige Power -Patches Zusätzlich zur Referenz -C -Implementierung.^[41]

Siehe auch

• Vergleich der Programmiersprachen

Verweise

Weitere Lektüre

• Ierusalimschy, R. (2013). Programmierung in Lua (3. Aufl.). Lua.org. ISBN 978-85-903798-5-0. (Der 1. Aufl. Ist verfügbar online.))
• Gutschmidt, T. (2003). Spielprogrammierung mit Python, Lua und Ruby. Kurs Technologie PTR. ISBN 978-1-59200-077-7.
• Schuytema, P.; Manyen, M. (2005). Spielentwicklung mit Lua. Charles River Media. ISBN 978-1-58450-404-7.
• Jung, K.; Brown, A. (2007). Beginn der Lua -Programmierung. Wrox Press. ISBN 978-0-470-06917-2. Archiviert von das Original am 8. Juli 2018. Abgerufen 7. Juli 2018.
• FigueiReiedo, L. H.; Celes, W.; Ierusalimschy, R., Hrsg. (2008). LUA -Programmiersteine. Lua.org. ISBN 978-85-903798-4-3.
• Takhteyev, Yuri (2012). Codierungsplätze: Softwarepraxis in einer südamerikanischen Stadt. Die MIT -Presse. ISBN 978-0-262-01807-4. Archiviert von das Original am 2. November 2012. Die Kapitel 6 und 7 sind Lua gewidmet, während andere Software in Brasilien allgemeiner betrachten.
• Varma, Jayant (2012). Lernen Sie Lua für iOS -Spielentwicklung. Apress. ISBN 978-1-4302-4662-6.
• Matheson, Ash (29. April 2003). "Eine Einführung in Lua". Gameev.net. Archiviert von das Original am 18. Dezember 2012. Abgerufen 3. Januar 2013.
• Fieldhouse, Keith (16. Februar 2006). "LUA einführen". Onlamp.com. O'Reilly Media. Archiviert von das Original am 12. März 2006. Abgerufen 28. Februar 2006.
• Streicher, Martin (28. April 2006). "Einbettbares Scripting mit Lua". Entwicklerworks. IBM. Archiviert von das Original am 2. Juli 2009. Abgerufen 7. Juli 2018.
• Quigley, Joseph (1. Juni 2007). "Ein Blick auf Lua". Linux Journal.
• Hamilton, Naomi (11. September 2008). "Der A-Z der Programmiersprachen: lua". Computerwelt. Idg. Archiviert von das Original am 8. Juli 2018. Abgerufen 7. Juli 2018. Interview mit Roberto Ierusalimschy.
• Ierusalimschy, Roberto; de Figueiredo, Luiz Henrique; Celes, Waldemar (12. Mai 2011). "Eine Sprache durch das Auge einer Nadel passieren". ACM -Warteschlange. 9 (5): 20–29. doi:10.1145/1978862.1983083. S2CID 19484689. Wie sich die Einbettbarkeit von Lua auf das Design auswirkte.
• Ierusalimschy, Roberto; de Figueiredo, Luiz Henrique; Celes, Waldemar (November 2018). "Ein Blick auf das Design von Lua". Kommunikation der ACM. 61 (11): 114–123. doi:10.1145/3186277. S2CID 53114923.^{[Permanent Dead Link]}
• Lua Papiere und Thesen

Externe Links

• Offizielle Website
• Lua -Benutzer, Gemeinschaft
• Lua Forum
• Luadist
• Lua Rocks - Paketmanager
• Projekte in Lua