Lua - Kurzanleitung

Lua ist eine erweiterbare, leichtgewichtige Programmiersprache, die in C geschrieben wurde. Sie wurde 1993 von Roberto Ierusalimschy, Luiz Henrique de Figueiredo und Waldemar Celes als internes Projekt gestartet.

Es wurde von Anfang an als Software entwickelt, die in den in C und andere herkömmliche Sprachen geschriebenen Code integriert werden kann. Diese Integration bringt viele Vorteile. Es versucht nicht, das zu tun, was C bereits kann, sondern zielt darauf ab, das anzubieten, was C nicht kann: einen guten Abstand zur Hardware, dynamische Strukturen, keine Redundanzen, einfache Tests und Fehlerbehebung. Dafür verfügt Lua über eine sichere Umgebung, eine automatische Speicherverwaltung und gute Funktionen für den Umgang mit Zeichenfolgen und anderen Arten von Daten mit dynamischer Größe.

Eigenschaften

Lua bietet eine Reihe einzigartiger Funktionen, die es von anderen Sprachen unterscheidet. Dazu gehören -

• Extensible
• Simple
• Efficient
• Portable
• Frei und offen

Beispielcode

print("Hello World!")

Wie wird Lua implementiert?

Lua besteht aus zwei Teilen - dem Lua-Dolmetscherteil und dem funktionierenden Softwaresystem. Das funktionierende Softwaresystem ist eine tatsächliche Computeranwendung, die in der Programmiersprache Lua geschriebene Programme interpretieren kann. Der Lua-Interpreter ist in ANSI C geschrieben, daher ist er sehr portabel und kann auf einem breiten Spektrum von Geräten ausgeführt werden, von High-End-Netzwerkservern bis hin zu kleinen Geräten.

Sowohl Luas Sprache als auch sein Dolmetscher sind ausgereift, klein und schnell. Es hat sich aus anderen Programmiersprachen und Top-Softwarestandards entwickelt. Aufgrund seiner geringen Größe kann es auf kleinen Geräten mit wenig Speicher ausgeführt werden.

Lua lernen

Der wichtigste Punkt beim Lernen von Lua ist, sich auf die Konzepte zu konzentrieren, ohne sich in den technischen Details zu verlieren.

Der Zweck des Lernens einer Programmiersprache besteht darin, ein besserer Programmierer zu werden. das heißt, beim Entwerfen und Implementieren neuer Systeme und beim Verwalten alter Systeme effektiver zu werden.

Einige Verwendungen von Lua

• Spielprogrammierung

• Skripterstellung in eigenständigen Anwendungen

• Skripterstellung im Web

• Erweiterungen und Add-Ons für Datenbanken wie MySQL Proxy und MySQL WorkBench

• Sicherheitssysteme wie Intrusion Detection System.

Einrichtung der lokalen Umgebung

Wenn Sie weiterhin bereit sind, Ihre Umgebung für die Programmiersprache Lua einzurichten, benötigen Sie die folgenden auf Ihrem Computer verfügbaren Softwareprogramme: (a) Texteditor, (b) Lua-Interpreter und (c) Lua-Compiler.

Texteditor

Sie benötigen einen Texteditor, um Ihr Programm einzugeben. Beispiele für einige Editoren sind Windows Notepad, OS Edit-Befehl, Brief, Epsilon, EMACS und vim oder vi.

Name und Version des Texteditors können auf verschiedenen Betriebssystemen variieren. Beispielsweise wird Notepad unter Windows verwendet, und vim oder vi können sowohl unter Windows als auch unter Linux oder UNIX verwendet werden.

Die Dateien, die Sie mit Ihrem Editor erstellen, werden als Quelldateien bezeichnet. Diese Dateien enthalten den Programmquellcode. Die Quelldateien für Lua-Programme werden normalerweise mit der Erweiterung benannt".lua".

Der Lua-Dolmetscher

Es ist nur ein kleines Programm, mit dem Sie Lua-Befehle eingeben und sofort ausführen lassen können. Es stoppt die Ausführung einer Lua-Datei, falls im Gegensatz zu einem Compiler, der vollständig ausgeführt wird, ein Fehler auftritt.

Der Lua Compiler

Wenn wir Lua auf andere Sprachen / Anwendungen erweitern, benötigen wir ein Software Development Kit mit einem Compiler, der mit der Lua Application Program Interface kompatibel ist.

Installation unter Windows

Es gibt eine separate IDE namens "SciTE", die für die Windows-Umgebung entwickelt wurde und von der heruntergeladen werden kann https://code.google.com/p/luaforwindows/ Download-Bereich.

Führen Sie die heruntergeladene ausführbare Datei aus, um die Lua-IDE zu installieren.

Da es sich um eine IDE handelt, können Sie den Lua-Code mit demselben erstellen und erstellen.

Wenn Sie Lua im Befehlszeilenmodus installieren möchten, müssen Sie MinGW oder Cygwin installieren und dann Lua in Windows kompilieren und installieren.

Installation unter Linux

Verwenden Sie den folgenden Befehl, um Lua herunterzuladen und zu erstellen:

$ wget http://www.lua.org/ftp/lua-5.2.3.tar.gz $ tar zxf lua-5.2.3.tar.gz
$ cd lua-5.2.3 $ make linux test

Um auf anderen Plattformen wie aix, ansi, bsd, generischem Linux, mingw, posix, solaris durch Ersetzen von Linux in make Linux zu installieren, testen Sie mit dem entsprechenden Plattformnamen.

Wir haben eine helloWorld.lua in Lua wie folgt -

print("Hello World!")

Jetzt können wir eine Lua-Datei erstellen und ausführen, z. B. helloWorld.lua, indem wir mit cd in den Ordner mit der Datei wechseln und dann den folgenden Befehl verwenden:

$ lua helloWorld

Wir können die folgende Ausgabe sehen.

Hello World!

Installation unter Mac OS X.

Verwenden Sie den folgenden Befehl, um Lua unter Mac OS X zu erstellen / zu testen:

$ curl -R -O http://www.lua.org/ftp/lua-5.2.3.tar.gz
$ tar zxf lua-5.2.3.tar.gz $ cd lua-5.2.3
$ make macosx test

In bestimmten Fällen haben Sie möglicherweise die Xcode- und Befehlszeilentools nicht installiert. In solchen Fällen können Sie den Befehl make nicht verwenden. Installieren Sie Xcode aus dem Mac App Store. Gehen Sie dann zu den Einstellungen von Xcode, wechseln Sie zu Downloads und installieren Sie die Komponente mit dem Namen "Command Line Tools". Sobald der Vorgang abgeschlossen ist, steht Ihnen der Befehl make zur Verfügung.

Es ist nicht zwingend erforderlich, dass Sie die Anweisung "make macosx test" ausführen. Auch ohne Ausführung dieses Befehls können Sie Lua unter Mac OS X verwenden.

Wir haben eine helloWorld.lua in Lua wie folgt:

print("Hello World!")

Jetzt können wir eine Lua-Datei erstellen und ausführen, z. B. helloWorld.lua, indem wir mit cd in den Ordner mit der Datei wechseln und dann den folgenden Befehl verwenden:

$ lua helloWorld

Wir können die folgende Ausgabe sehen -

Hello World!

Lua IDE

Wie bereits erwähnt, ist die Lua-IDE für Windows SciTE die Standard-IDE, die vom Lua-Erstellerteam bereitgestellt wird. Die verfügbare alternative IDE stammt von ZeroBrane Studio, das auf mehreren Plattformen wie Windows, Mac und Linux verfügbar ist.

Es gibt auch Plugins für Eclipse, die die Lua-Entwicklung ermöglichen. Die Verwendung von IDE erleichtert die Entwicklung mit Funktionen wie der Code-Vervollständigung und wird dringend empfohlen. Die IDE bietet auch eine interaktive Modusprogrammierung ähnlich der Befehlszeilenversion von Lua.

Beginnen wir mit der Erstellung unseres ersten Lua-Programms!

Erstes Lua-Programm

Programmierung im interaktiven Modus

Lua bietet einen Modus namens interaktiver Modus. In diesem Modus können Sie Anweisungen nacheinander eingeben und erhalten sofortige Ergebnisse. Dies kann in der Shell mit dem Befehl lua -i oder nur mit dem Befehl lua aufgerufen werden. Sobald Sie dies eingegeben haben, drücken Sie die Eingabetaste und der interaktive Modus wird wie unten gezeigt gestartet.

$ lua -i $ Lua 5.1.4  Copyright (C) 1994-2008 Lua.org, PUC-Rio
quit to end; cd, dir and edit also available

Sie können etwas mit der folgenden Anweisung drucken:

print("test")

Sobald Sie die Eingabetaste drücken, erhalten Sie die folgende Ausgabe:

test

Standardmodus-Programmierung

Das Aufrufen des Interpreters mit einem Lua-Dateinamenparameter beginnt mit der Ausführung der Datei und wird fortgesetzt, bis das Skript beendet ist. Wenn das Skript fertig ist, ist der Interpreter nicht mehr aktiv.

Schreiben wir ein einfaches Lua-Programm. Alle Lua-Dateien haben die Erweiterung .lua. Fügen Sie also den folgenden Quellcode in eine test.lua-Datei ein.

print("test")

Angenommen, die Lua-Umgebung ist korrekt eingerichtet, führen wir das Programm mit dem folgenden Code aus:

$ lua test.lua

Wir werden die folgende Ausgabe erhalten -

test

Versuchen wir einen anderen Weg, um ein Lua-Programm auszuführen. Unten ist die geänderte Datei test.lua -

#!/usr/local/bin/lua

print("test")

Hier haben wir angenommen, dass Sie einen Lua-Interpreter in Ihrem Verzeichnis / usr / local / bin verfügbar haben. Die erste Zeile wird vom Interpreter ignoriert, wenn sie mit dem Zeichen # beginnt. Versuchen Sie nun, dieses Programm wie folgt auszuführen:

$ chmod a+rx test.lua
$./test.lua

Wir werden die folgende Ausgabe erhalten.

test

Lassen Sie uns nun die Grundstruktur des Lua-Programms sehen, damit Sie die Grundbausteine ​​der Lua-Programmiersprache leicht verstehen können.

Token in Lua

Ein Lua-Programm besteht aus verschiedenen Token, und ein Token ist entweder ein Schlüsselwort, ein Bezeichner, eine Konstante, ein Zeichenfolgenliteral oder ein Symbol. Zum Beispiel besteht die folgende Lua-Anweisung aus drei Token -

io.write("Hello world, from ",_VERSION,"!\n")

Die einzelnen Token sind -

io.write
(
   "Hello world, from ",_VERSION,"!\n"
)

Bemerkungen

Kommentare sind wie Hilfetexte in Ihrem Lua-Programm und werden vom Dolmetscher ignoriert. Sie beginnen mit - [[und enden mit den Zeichen -]] wie unten gezeigt -

--[[ my first program in Lua --]]

Kennungen

Ein Lua-Bezeichner ist ein Name, mit dem eine Variable, eine Funktion oder ein anderes benutzerdefiniertes Element identifiziert wird. Ein Bezeichner beginnt mit einem Buchstaben 'A bis Z' oder 'a bis z' oder einem Unterstrich '_', gefolgt von null oder mehr Buchstaben, Unterstrichen und Ziffern (0 bis 9).

Lua erlaubt keine Interpunktionszeichen wie @, $ und% in Bezeichnern. Lua ist eincase sensitiveProgrammiersprache. So Manpower und Manpower sind zwei verschiedene Kennungen in Lua. Hier sind einige Beispiele für akzeptable Bezeichner -

mohd         zara      abc     move_name    a_123
myname50     _temp     j       a23b9        retVal

Schlüsselwörter

Die folgende Liste zeigt einige der reservierten Wörter in Lua. Diese reservierten Wörter dürfen nicht als Konstanten oder Variablen oder andere Bezeichnernamen verwendet werden.

und	Unterbrechung	tun	sonst
elseif	Ende	falsch	zum
Funktion	wenn	im	lokal
Null	nicht	oder	wiederholen
Rückkehr	dann	wahr	bis um
während

Leerzeichen in Lua

Eine Zeile, die nur Leerzeichen enthält, möglicherweise mit einem Kommentar, wird als Leerzeile bezeichnet, und ein Lua-Interpreter ignoriert sie vollständig.

Whitespace ist der Begriff, der in Lua verwendet wird, um Leerzeichen, Tabulatoren, Zeilenumbrüche und Kommentare zu beschreiben. Whitespace trennt einen Teil einer Anweisung von einem anderen und ermöglicht dem Interpreter zu identifizieren, wo ein Element in einer Anweisung, wie z. B. int, endet und das nächste Element beginnt. Daher in der folgenden Aussage -

local age

Es muss mindestens ein Leerzeichen (normalerweise ein Leerzeichen) zwischen lokal und Alter vorhanden sein, damit der Interpreter sie unterscheiden kann. Auf der anderen Seite in der folgenden Aussage -

fruit = apples + oranges   --get the total fruit

Zwischen Obst und = oder zwischen = und Äpfeln sind keine Leerzeichen erforderlich, obwohl Sie einige hinzufügen können, wenn Sie dies aus Gründen der Lesbarkeit wünschen.

Eine Variable ist nichts anderes als ein Name für einen Speicherbereich, den unsere Programme bearbeiten können. Es kann verschiedene Arten von Werten enthalten, einschließlich Funktionen und Tabellen.

Der Name einer Variablen kann aus Buchstaben, Ziffern und dem Unterstrich bestehen. Es muss entweder mit einem Buchstaben oder einem Unterstrich beginnen. Groß- und Kleinbuchstaben unterscheiden sich, da bei Lua zwischen Groß- und Kleinschreibung unterschieden wird. Es gibt acht grundlegende Arten von Werten in Lua -

In Lua gibt es zwar keine variablen Datentypen, aber drei Typen, die auf dem Umfang der Variablen basieren.

• Global variables - Alle Variablen werden als global betrachtet, sofern sie nicht ausdrücklich als lokal deklariert sind.

• Local variables - Wenn der Typ für eine Variable als lokal angegeben wird, ist sein Gültigkeitsbereich auf die Funktionen in ihrem Gültigkeitsbereich beschränkt.

• Table fields - Dies ist ein spezieller Variablentyp, der alles außer Null einschließlich Funktionen enthalten kann.

Variablendefinition in Lua

Eine Variablendefinition bedeutet, dem Interpreter mitzuteilen, wo und wie viel Speicher für die Variable erstellt werden soll. Eine Variablendefinition hat einen optionalen Typ und enthält eine Liste einer oder mehrerer Variablen dieses Typs wie folgt:

type variable_list;

Hier, type ist optional lokal oder vom Typ angegeben, wodurch es global wird, und variable_listkann aus einem oder mehreren durch Kommas getrennten Bezeichnernamen bestehen. Einige gültige Erklärungen werden hier angezeigt -

local    i, j
local    i
local    a,c

Die Linie local i, jbeide deklarieren und definieren die Variablen i und j; Dies weist den Interpreter an, Variablen mit den Namen i, j zu erstellen, und begrenzt den Bereich auf lokal.

Variablen können in ihrer Deklaration initialisiert (mit einem Anfangswert versehen) werden. Der Initialisierer besteht aus einem Gleichheitszeichen, gefolgt von einem konstanten Ausdruck wie folgt:

type variable_list = value_list;

Einige Beispiele sind -

local d , f = 5 ,10     --declaration of d and f as local variables. 
d , f = 5, 10;          --declaration of d and f as global variables. 
d, f = 10               --[[declaration of d and f as global variables. 
                           Here value of f is nil --]]

Für die Definition ohne Initialisierer: Variablen mit statischer Speicherdauer werden implizit mit nil initialisiert.

Variable Deklaration in Lua

Wie Sie in den obigen Beispielen sehen können, folgen Zuweisungen für mehrere Variablen einem Format für variable_list und value_list. Im obigen Beispiellocal d, f = 5,10 Wir haben d und f in variable_list und 5 und 10 in der Werteliste.

Die Wertzuweisung in Lua erfolgt wie die erste Variable in der Variablenliste mit dem ersten Wert in der Werteliste und so weiter. Daher ist der Wert von d 5 und der Wert von f ist 10.

Beispiel

Versuchen Sie das folgende Beispiel, in dem Variablen oben deklariert, aber innerhalb der Hauptfunktion definiert und initialisiert wurden.

-- Variable definition:
local a, b

-- Initialization
a = 10
b = 30

print("value of a:", a)

print("value of b:", b)

-- Swapping of variables
b, a = a, b

print("value of a:", a)

print("value of b:", b)

f = 70.0/3.0
print("value of f", f)

Wenn der obige Code erstellt und ausgeführt wird, wird das folgende Ergebnis erzeugt:

value of a:	10
value of b:	30
value of a:	30
value of b:	10
value of f	23.333333333333

LWerte und RWerte in Lua

Es gibt zwei Arten von Ausdrücken in Lua -

• lvalue- Ausdrücke, die sich auf einen Speicherort beziehen, werden als "lvalue" -Ausdruck bezeichnet. Ein Wert kann entweder als linke oder rechte Seite einer Zuweisung angezeigt werden.

• rvalue- Der Begriff rWert bezieht sich auf einen Datenwert, der an einer bestimmten Adresse im Speicher gespeichert ist. Ein r-Wert ist ein Ausdruck, dem kein Wert zugewiesen werden kann. Dies bedeutet, dass ein r-Wert möglicherweise auf der rechten Seite, jedoch nicht auf der linken Seite einer Zuweisung angezeigt wird.

Variablen sind l-Werte und können daher auf der linken Seite einer Zuweisung angezeigt werden. Numerische Literale sind r-Werte und können daher nicht zugewiesen werden und können nicht auf der linken Seite angezeigt werden. Es folgt eine gültige Aussage -

g = 20

Das Folgende ist jedoch keine gültige Aussage und würde einen Build-Time-Fehler erzeugen -

10 = 20

In der Programmiersprache Lua ist es abgesehen von den oben genannten Zuweisungstypen möglich, mehrere l- und r-Werte in derselben einzelnen Anweisung zu haben. Es ist unten gezeigt.

g,l = 20,30

In der obigen Aussage ist 20 g und 30 l zugeordnet.

Lua ist eine dynamisch typisierte Sprache, daher haben die Variablen keine Typen, nur die Werte haben Typen. Werte können in Variablen gespeichert, als Parameter übergeben und als Ergebnisse zurückgegeben werden.

In Lua haben wir zwar keine variablen Datentypen, aber Typen für die Werte. Die Liste der Datentypen für Werte ist unten angegeben.

Sr.Nr.	Werttyp & Beschreibung
1	nil Wird verwendet, um den Wert von Daten oder keinen (Null-) Daten zu unterscheiden.
2	boolean Schließt wahr und falsch als Werte ein. Wird im Allgemeinen zur Zustandsprüfung verwendet.
3	number Repräsentiert reelle Zahlen (Gleitkommazahlen mit doppelter Genauigkeit).
4	string Repräsentiert ein Array von Zeichen.
5	function Stellt eine Methode dar, die in C oder Lua geschrieben ist.
6	userdata Repräsentiert beliebige C-Daten.
7	thread Stellt unabhängige Ausführungsthreads dar und wird zum Implementieren von Coroutinen verwendet.
8	table Stellen Sie gewöhnliche Arrays, Symboltabellen, Mengen, Datensätze, Diagramme, Bäume usw. dar und implementieren Sie assoziative Arrays. Es kann einen beliebigen Wert enthalten (außer Null).

Typ Funktion

In Lua gibt es eine Funktion namens 'type', mit der wir den Typ der Variablen kennen. Einige Beispiele finden Sie im folgenden Code.

print(type("What is my type"))   --> string
t = 10

print(type(5.8*t))               --> number
print(type(true))                --> boolean
print(type(print))               --> function
print(type(nil))                 --> nil
print(type(type(ABC)))           --> string

Wenn Sie das obige Programm erstellen und ausführen, wird unter Linux das folgende Ergebnis erzielt:

string
number
boolean
function
nil
string

Standardmäßig zeigen alle Variablen auf Null, bis ihnen ein Wert zugewiesen oder initialisiert wird. In Lua werden Null- und Leerzeichenfolgen bei Bedingungsprüfungen als wahr angesehen. Daher müssen Sie bei der Verwendung von Booleschen Operationen vorsichtig sein. Wir werden in den nächsten Kapiteln mehr über diese Typen erfahren.

Ein Operator ist ein Symbol, das den Interpreter anweist, bestimmte mathematische oder logische Manipulationen durchzuführen. Die Lua-Sprache ist reich an integrierten Operatoren und bietet die folgenden Operatortypen:

• Rechenzeichen
• Vergleichsoperatoren
• Logische Operatoren
• Verschiedene Operatoren

In diesem Tutorial werden die arithmetischen, relationalen, logischen und anderen verschiedenen Operatoren nacheinander erläutert.

Rechenzeichen

Die folgende Tabelle zeigt alle arithmetischen Operatoren, die von der Lua-Sprache unterstützt werden. Variable annehmenA hält 10 und variabel B hält dann 20 -

Beispiele anzeigen

Operator	Beschreibung	Beispiel
+	Fügt zwei Operanden hinzu	A + B ergibt 30
- -	Subtrahiert den zweiten Operanden vom ersten	A - B ergibt -10
* *	Multiplizieren Sie beide Operanden	A * B ergibt 200
/.	Teilen Sie den Zähler durch den De-Zähler	B / A ergibt 2
%.	Modul Operator und Rest nach einer ganzzahligen Division	B% A ergibt 0
^	Exponent Operator nimmt die Exponenten	A ^ 2 ergibt 100
- -	Unary - Operator fungiert als Negation	-A gibt -10

Vergleichsoperatoren

Die folgende Tabelle zeigt alle relationalen Operatoren, die von der Lua-Sprache unterstützt werden. Variable annehmenA hält 10 und variabel B hält dann 20 -

Beispiele anzeigen

Operator	Beschreibung	Beispiel
==	Überprüft, ob der Wert von zwei Operanden gleich ist oder nicht. Wenn ja, wird die Bedingung wahr.	(A == B) ist nicht wahr.
~ =	Überprüft, ob der Wert von zwei Operanden gleich ist oder nicht. Wenn die Werte nicht gleich sind, wird die Bedingung wahr.	(A ~ = B) ist wahr.
>	Überprüft, ob der Wert des linken Operanden größer als der Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr.	(A> B) ist nicht wahr.
<	Überprüft, ob der Wert des linken Operanden kleiner als der Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr.	(A <B) ist wahr.
> =	Überprüft, ob der Wert des linken Operanden größer oder gleich dem Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr.	(A> = B) ist nicht wahr.
<=	Überprüft, ob der Wert des linken Operanden kleiner oder gleich dem Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr.	(A <= B) ist wahr.

Logische Operatoren

Die folgende Tabelle zeigt alle logischen Operatoren, die von der Lua-Sprache unterstützt werden. Variable annehmenA gilt wahr und variabel B gilt dann falsch -

Beispiele anzeigen

Operator	Beschreibung	Beispiel
und	Wird als logischer UND-Operator bezeichnet. Wenn beide Operanden nicht Null sind, wird die Bedingung wahr.	(A und B) ist falsch.
oder	Wird als logischer ODER-Operator bezeichnet. Wenn einer der beiden Operanden nicht Null ist, wird die Bedingung wahr.	(A oder B) ist wahr.
nicht	Wird als logischer NICHT-Operator bezeichnet. Verwenden Sie diese Option, um den logischen Status des Operanden umzukehren. Wenn eine Bedingung wahr ist, macht der Operator Logical NOT false.	! (A und B) ist wahr.

Verschiedene Operatoren

Verschiedene von Lua Language unterstützte Operatoren umfassen concatenation und length.

Beispiele anzeigen

Operator	Beschreibung	Beispiel
..	Verkettet zwei Zeichenfolgen.	a..b wobei a "Hallo" und b "Welt" ist, wird "Hallo Welt" zurückgegeben.
#	Ein unärer Operator, der die Länge einer Zeichenfolge oder einer Tabelle zurückgibt.	# "Hallo" gibt 5 zurück

Vorrang der Betreiber in Lua

Die Operatorrangfolge bestimmt die Gruppierung von Begriffen in einem Ausdruck. Dies wirkt sich darauf aus, wie ein Ausdruck ausgewertet wird. Bestimmte Operatoren haben eine höhere Priorität als andere. Beispielsweise hat der Multiplikationsoperator eine höhere Priorität als der Additionsoperator -

Zum Beispiel ist x = 7 + 3 * 2; Hier wird x 13 zugewiesen, nicht 20, da der Operator * eine höhere Priorität als + hat, sodass er zuerst mit 3 * 2 multipliziert und dann zu 7 addiert wird.

Hier werden Operatoren mit der höchsten Priorität oben in der Tabelle angezeigt, Operatoren mit der niedrigsten Priorität unten. Innerhalb eines Ausdrucks werden zuerst Operatoren mit höherer Priorität ausgewertet.

Beispiele anzeigen

Kategorie	Operator	Assoziativität
Einstellig	nicht # -	Rechts nach links
Verkettung	..	Rechts nach links
Multiplikativ	* /%	Links nach rechts
Zusatzstoff	+ -	Links nach rechts
Relational	<> <=> = == ~ =	Links nach rechts
Gleichberechtigung	== ~ =	Links nach rechts
Logisches UND	und	Links nach rechts
Logisches ODER	oder	Links nach rechts

Es kann vorkommen, dass Sie einen Codeblock mehrmals ausführen müssen. Im Allgemeinen werden Anweisungen nacheinander ausgeführt: Die erste Anweisung in einer Funktion wird zuerst ausgeführt, gefolgt von der zweiten usw.

Programmiersprachen bieten verschiedene Steuerungsstrukturen, die kompliziertere Ausführungspfade ermöglichen.

Mit einer Schleifenanweisung können wir eine Anweisung oder eine Gruppe von Anweisungen mehrmals ausführen. Es folgt die allgemeine Form einer Schleifenanweisung in den meisten Programmiersprachen -

Lua bietet die folgenden Arten von Schleifen an, um die Schleifenanforderungen zu erfüllen.

Sr.Nr.	Schleifentyp & Beschreibung
1	while-Schleife Wiederholt eine Anweisung oder eine Gruppe von Anweisungen, während eine bestimmte Bedingung erfüllt ist. Es testet die Bedingung, bevor der Schleifenkörper ausgeführt wird.
2	für Schleife Führt eine Folge von Anweisungen mehrmals aus und verkürzt den Code, der die Schleifenvariable verwaltet.
3	Wiederholen ... bis Schleife Wiederholt den Vorgang einer Gruppe von Anweisungen, bis die Bedingung bis erfüllt ist.
4	verschachtelte Schleifen Sie können eine oder mehrere Schleifen in einer anderen while-, for- oder do..while- Schleife verwenden.

Schleifensteuerungsanweisung

Die Schleifensteueranweisung ändert die Ausführung von ihrer normalen Reihenfolge. Wenn die Ausführung einen Bereich verlässt, werden alle automatischen Objekte, die in diesem Bereich erstellt wurden, zerstört.

Lua unterstützt die folgenden Steueranweisungen.

Sr.Nr.	Steueranweisung & Beschreibung
1	break-Anweisung Beendet die loop und überträgt die Ausführung an die Anweisung unmittelbar nach der Schleife oder dem Schalter.

Die Endlosschleife

Eine Schleife wird zur Endlosschleife, wenn eine Bedingung niemals falsch wird. DaswhileZu diesem Zweck wird häufig eine Schleife verwendet. Da wir für die Bedingung direkt true angeben, wird sie für immer ausgeführt. Wir können die break-Anweisung verwenden, um diese Schleife zu unterbrechen.

while( true )
do
   print("This loop will run forever.")
end

Entscheidungsstrukturen erfordern, dass der Programmierer eine oder mehrere Bedingungen angibt, die vom Programm ausgewertet oder getestet werden sollen, zusammen mit einer Anweisung oder Anweisungen, die ausgeführt werden sollen, wenn die Bedingung als wahr bestimmt wird, und optional andere Anweisungen, die ausgeführt werden sollen, wenn die Bedingung wird als falsch bestimmt.

Es folgt die allgemeine Form einer typischen Entscheidungsstruktur, die in den meisten Programmiersprachen zu finden ist:

Die Programmiersprache Lua setzt eine beliebige Kombination von Booleschen Werten voraus true und non-nil Werte als trueund wenn es entweder boolesch ist false oder nildann wird angenommen als falseWert. Es ist zu beachten, dass in Lua,zero will be considered as true.

Die Programmiersprache Lua bietet die folgenden Arten von Entscheidungsaussagen.

Sr.Nr.	Aussage & Beschreibung
1	if-Anweisung Eine if- Anweisung besteht aus einem booleschen Ausdruck, gefolgt von einer oder mehreren Anweisungen.
2	if ... else-Anweisung Auf eine if- Anweisung kann eine optionale else- Anweisung folgen , die ausgeführt wird, wenn der boolesche Ausdruck false ist.
3	verschachtelte if-Anweisungen Sie können eine if- oder if- Anweisung in einer anderen if- oder if- Anweisung verwenden.

Eine Funktion ist eine Gruppe von Anweisungen, die zusammen eine Aufgabe ausführen. Sie können Ihren Code in separate Funktionen aufteilen. Wie Sie Ihren Code auf verschiedene Funktionen aufteilen, liegt bei Ihnen. Logischerweise ist die Aufteilung normalerweise eindeutig, sodass jede Funktion eine bestimmte Aufgabe ausführt.

Die Lua-Sprache bietet zahlreiche integrierte Methoden, die Ihr Programm aufrufen kann. Zum Beispiel Methodeprint() um das als Eingabe in der Konsole übergebene Argument zu drucken.

Eine Funktion ist mit verschiedenen Namen wie einer Methode oder einer Unterroutine oder einer Prozedur usw. bekannt.

Funktion definieren

Die allgemeine Form einer Methodendefinition in der Programmiersprache Lua lautet wie folgt:

optional_function_scope function function_name( argument1, argument2, argument3........, 
argumentn)
function_body
return result_params_comma_separated
end

Eine Methodendefinition in der Programmiersprache Lua besteht aus einem Methodenkopf und einem Methodenkörper . Hier sind alle Teile einer Methode -

• Optional Function Scope- Sie können das Schlüsselwort local verwenden , um den Funktionsumfang einzuschränken, oder den Bereichsbereich ignorieren, wodurch es zu einer globalen Funktion wird.

• Function Name- Dies ist der tatsächliche Name der Funktion. Der Funktionsname und die Parameterliste bilden zusammen die Funktionssignatur.

• Arguments- Ein Argument ist wie ein Platzhalter. Wenn eine Funktion aufgerufen wird, übergeben Sie dem Argument einen Wert. Dieser Wert wird als tatsächlicher Parameter oder Argument bezeichnet. Die Parameterliste bezieht sich auf den Typ, die Reihenfolge und die Anzahl der Argumente einer Methode. Argumente sind optional; Das heißt, eine Methode darf kein Argument enthalten.

• Function Body - Der Methodenkörper enthält eine Sammlung von Anweisungen, die definieren, was die Methode tut.

• Return - In Lua ist es möglich, mehrere Werte zurückzugeben, indem Sie dem Schlüsselwort return mit den durch Kommas getrennten Rückgabewerten folgen.

Beispiel

Es folgt der Quellcode für eine aufgerufene Funktion max(). Diese Funktion verwendet zwei Parameter num1 und num2 und gibt das Maximum zwischen den beiden zurück -

--[[ function returning the max between two numbers --]]
function max(num1, num2)

   if (num1 > num2) then
      result = num1;
   else
      result = num2;
   end

   return result; 
end

Funktionsargumente

Wenn eine Funktion Argumente verwenden soll, muss sie die Variablen deklarieren, die die Werte der Argumente akzeptieren. Diese Variablen werden als bezeichnetformal parameters der Funktion.

Die formalen Parameter verhalten sich wie andere lokale Variablen innerhalb der Funktion und werden beim Eintritt in die Funktion erstellt und beim Beenden zerstört.

Eine Funktion aufrufen

Beim Erstellen einer Lua-Funktion definieren Sie, was die Funktion zu tun hat. Um eine Methode zu verwenden, müssen Sie diese Funktion aufrufen, um die definierte Aufgabe auszuführen.

Wenn ein Programm eine Funktion aufruft, wird die Programmsteuerung auf die aufgerufene Funktion übertragen. Eine aufgerufene Funktion führt die definierte Aufgabe aus. Wenn ihre return-Anweisung ausgeführt wird oder wenn das Ende ihrer Funktion erreicht ist, gibt sie die Programmsteuerung an das Hauptprogramm zurück.

Um eine Methode aufzurufen, müssen Sie lediglich die erforderlichen Parameter zusammen mit dem Methodennamen übergeben. Wenn die Methode einen Wert zurückgibt, können Sie den zurückgegebenen Wert speichern. Zum Beispiel -

function max(num1, num2)

   if (num1 > num2) then
      result = num1;
   else
      result = num2;
   end

   return result; 
end

-- calling a function
print("The maximum of the two numbers is ",max(10,4))
print("The maximum of the two numbers is ",max(5,6))

Wenn wir den obigen Code ausführen, erhalten wir die folgende Ausgabe.

The maximum of the two numbers is 	10
The maximum of the two numbers is 	6

Funktionen zuweisen und übergeben

In Lua können wir die Funktion Variablen zuweisen und sie auch als Parameter einer anderen Funktion übergeben. Hier ist ein einfaches Beispiel für das Zuweisen und Übergeben einer Funktion als Parameter in Lua.

myprint = function(param)
   print("This is my print function -   ##",param,"##")
end

function add(num1,num2,functionPrint)
   result = num1 + num2
   functionPrint(result)
end

myprint(10)
add(2,5,myprint)

Wenn wir den obigen Code ausführen, erhalten wir die folgende Ausgabe.

This is my print function -   ##	10	##
This is my print function -   ##	7	##

Funktion mit variablem Argument

Es ist möglich, Funktionen mit variablen Argumenten in Lua zu erstellen, indem '...' als Parameter verwendet wird. Wir können dies anhand eines Beispiels verstehen, in dem die Funktion den Durchschnitt zurückgibt und variable Argumente annehmen kann.

function average(...)
   result = 0
   local arg = {...}
   for i,v in ipairs(arg) do
      result = result + v
   end
   return result/#arg
end

print("The average is",average(10,5,3,4,5,6))

Wenn wir den obigen Code ausführen, erhalten wir die folgende Ausgabe.

The average is	5.5

String ist eine Folge von Zeichen sowie Steuerzeichen wie Formularvorschub. Der String kann mit drei Formularen initialisiert werden, darunter:

• Zeichen zwischen einfachen Anführungszeichen
• Zeichen zwischen doppelten Anführungszeichen
• Zeichen zwischen [[und]]

Ein Beispiel für die obigen drei Formen ist unten gezeigt.

string1 = "Lua"
print("\"String 1 is\"",string1)

string2 = 'Tutorial'
print("String 2 is",string2)

string3 = [["Lua Tutorial"]]
print("String 3 is",string3)

Wenn wir das obige Programm ausführen, erhalten wir die folgende Ausgabe.

"String 1 is" Lua
String 2 is	Tutorial
String 3 is	"Lua Tutorial"

Escape-Sequenzzeichen werden in Zeichenfolgen verwendet, um die normale Interpretation von Zeichen zu ändern. Um beispielsweise doppelte Anführungszeichen ("") zu drucken, haben wir im obigen Beispiel \ "verwendet. Die Escape-Sequenz und ihre Verwendung sind unten in der Tabelle aufgeführt.

Fluchtabfolge	Verwenden
\ein	Glocke
\ b	Rücktaste
\ f	Formfeed
\ n	Neue Zeile
\ r	Wagenrücklauf
\ t	Tab
\ v	Vertikale Registerkarte
\\	Backslash
""	Anführungszeichen
\ '	Einzelzitate
\ [	Linke eckige Klammer
\]	Rechte eckige Klammer

String-Manipulation

Lua unterstützt String, um Strings zu manipulieren -

Sr.Nr.	Methode & Zweck
1	string.upper(argument) Gibt eine großgeschriebene Darstellung des Arguments zurück.
2	string.lower(argument) Gibt eine Darstellung des Arguments in Kleinbuchstaben zurück.
3	string.gsub(mainString,findString,replaceString) Gibt eine Zeichenfolge zurück, indem findString durch replaceString ersetzt wird.
4	string.find(mainString,findString, optionalStartIndex,optionalEndIndex) Gibt den Startindex und den Endindex des findString in der Hauptzeichenfolge zurück und nil, falls nicht gefunden.
5	string.reverse(arg) Gibt eine Zeichenfolge zurück, indem die Zeichen der übergebenen Zeichenfolge umgekehrt werden.
6	string.format(...) Gibt eine formatierte Zeichenfolge zurück.
7	string.char(arg) and string.byte(arg) Gibt interne numerische und Zeichendarstellungen des Eingabearguments zurück.
8	string.len(arg) Gibt eine Länge der übergebenen Zeichenfolge zurück.
9	string.rep(string, n)) Gibt eine Zeichenfolge zurück, indem dieselbe Zeichenfolge n-mal wiederholt wird.
10	.. Somit verkettet der Operator zwei Zeichenfolgen.

Lassen Sie uns nun einige Beispiele betrachten, um genau zu sehen, wie sich diese Funktionen zur Manipulation von Zeichenfolgen verhalten.

Fallmanipulation

Ein Beispielcode zum Bearbeiten der Zeichenfolgen in Groß- und Kleinbuchstaben ist unten angegeben.

string1 = "Lua";

print(string.upper(string1))
print(string.lower(string1))

Wenn wir das obige Programm ausführen, erhalten wir die folgende Ausgabe.

LUA
lua

Ersetzen eines Teilstrings

Ein Beispielcode zum Ersetzen von Vorkommen einer Zeichenfolge durch eine andere ist unten angegeben.

string = "Lua Tutorial"

-- replacing strings
newstring = string.gsub(string,"Tutorial","Language")
print("The new string is "..newstring)

Wenn wir das obige Programm ausführen, erhalten wir die folgende Ausgabe.

The new string is Lua Language

Finden und Umkehren

Ein Beispielcode zum Ermitteln des Index der Teilzeichenfolge und der Umkehrzeichenfolge ist unten angegeben.

string = "Lua Tutorial"

-- replacing strings
print(string.find(string,"Tutorial"))
reversedString = string.reverse(string)
print("The new string is",reversedString)

Wenn wir das obige Programm ausführen, erhalten wir die folgende Ausgabe.

5	12
The new string is	lairotuT auL

Zeichenfolgen formatieren

In unserer Programmierung müssen wir möglicherweise häufig Zeichenfolgen formatiert drucken. Mit der Funktion string.format können Sie die Ausgabe wie unten gezeigt formatieren.

string1 = "Lua"
string2 = "Tutorial"

number1 = 10
number2 = 20

-- Basic string formatting
print(string.format("Basic formatting %s %s",string1,string2))

-- Date formatting
date = 2; month = 1; year = 2014
print(string.format("Date formatting %02d/%02d/%03d", date, month, year))

-- Decimal formatting
print(string.format("%.4f",1/3))

Wenn wir das obige Programm ausführen, erhalten wir die folgende Ausgabe.

Basic formatting Lua Tutorial
Date formatting 02/01/2014
0.3333

Zeichen- und Byte-Darstellungen

Ein Beispielcode für die Zeichen- und Bybedarstellung, der zum Konvertieren der Zeichenfolge von einer Zeichenfolge in eine interne Darstellung und umgekehrt verwendet wird.

-- Byte conversion

-- First character
print(string.byte("Lua"))

-- Third character
print(string.byte("Lua",3))

-- first character from last
print(string.byte("Lua",-1))

-- Second character
print(string.byte("Lua",2))

-- Second character from last
print(string.byte("Lua",-2))

-- Internal Numeric ASCII Conversion
print(string.char(97))

Wenn wir das obige Programm ausführen, erhalten wir die folgende Ausgabe.

76
97
97
117
117
a

Andere allgemeine Funktionen

Die gängigen Zeichenfolgenmanipulationen umfassen die Verkettung von Zeichenfolgen, das Ermitteln der Länge der Zeichenfolge und manchmal das wiederholte Wiederholen derselben Zeichenfolge. Das Beispiel für diese Operationen ist unten angegeben.

string1 = "Lua"
string2 = "Tutorial"

-- String Concatenations using ..
print("Concatenated string",string1..string2)

-- Length of string
print("Length of string1 is ",string.len(string1))

-- Repeating strings
repeatedString = string.rep(string1,3)
print(repeatedString)

Wenn wir das obige Programm ausführen, erhalten wir die folgende Ausgabe.

Concatenated string	LuaTutorial
Length of string1 is 	3
LuaLuaLua

Arrays sind geordnete Anordnungen von Objekten, die ein eindimensionales Array mit einer Sammlung von Zeilen oder ein mehrdimensionales Array mit mehreren Zeilen und Spalten sein können.

In Lua werden Arrays mithilfe von Indizierungstabellen mit Ganzzahlen implementiert. Die Größe eines Arrays ist nicht festgelegt und kann aufgrund von Speicherbeschränkungen aufgrund unserer Anforderungen wachsen.

Eindimensionales Array

Ein eindimensionales Array kann mit einer einfachen Tabellenstruktur dargestellt und mit einer einfachen initialisiert und gelesen werden forSchleife. Ein Beispiel ist unten gezeigt.

array = {"Lua", "Tutorial"}

for i = 0, 2 do
   print(array[i])
end

Wenn wir den obigen Code ausführen, erhalten wir die folgende Ausgabe.

nil
Lua
Tutorial

Wie Sie im obigen Code sehen können, gibt es beim Versuch, auf ein Element in einem Index zuzugreifen, das nicht im Array vorhanden ist, null zurück. In Lua beginnt die Indizierung im Allgemeinen bei Index 1. Es ist jedoch auch möglich, Objekte bei Index 0 und unter 0 zu erstellen. Das Array mit negativen Indizes wird unten gezeigt, wo wir das Array mit einer for- Schleife initialisieren .

array = {}

for i= -2, 2 do
   array[i] = i *2
end

for i = -2,2 do
   print(array[i])
end

Wenn wir den obigen Code ausführen, erhalten wir die folgende Ausgabe.

-4
-2
0
2
4

Mehrdimensionales Array

Mehrdimensionale Arrays können auf zwei Arten implementiert werden.

• Array von Arrays
• Eindimensionales Array durch Manipulieren von Indizes

Ein Beispiel für ein mehrdimensionales Array von 3, 3 wird unten unter Verwendung eines Arrays von Arrays gezeigt.

-- Initializing the array
array = {}

for i=1,3 do
   array[i] = {}
	
   for j=1,3 do
      array[i][j] = i*j
   end
	
end

-- Accessing the array

for i=1,3 do

   for j=1,3 do
      print(array[i][j])
   end
	
end

Wenn wir den obigen Code ausführen, erhalten wir die folgende Ausgabe.

1
2
3
2
4
6
3
6
9

Ein Beispiel für ein mehrdimensionales Array wird unten unter Verwendung von Manipulationsindizes gezeigt.

-- Initializing the array

array = {}

maxRows = 3
maxColumns = 3

for row=1,maxRows do

   for col=1,maxColumns do
      array[row*maxColumns +col] = row*col
   end
	
end

-- Accessing the array

for row=1,maxRows do

   for col=1,maxColumns do
      print(array[row*maxColumns +col])
   end
	
end

Wenn wir den obigen Code ausführen, erhalten wir die folgende Ausgabe.

1
2
3
2
4
6
3
6
9

Wie Sie im obigen Beispiel sehen können, werden Daten basierend auf Indizes gespeichert. Es ist möglich, die Elemente spärlich zu platzieren, und so funktioniert die Lua-Implementierung einer Matrix. Da in Lua keine Nullwerte gespeichert werden, ist es möglich, ohne spezielle Technik in Lua viel Speicherplatz zu sparen, im Vergleich zu speziellen Techniken, die in anderen Programmiersprachen verwendet werden.

Iterator ist ein Konstrukt, mit dem Sie die Elemente der sogenannten Sammlung oder des Containers durchlaufen können. In Lua beziehen sich diese Sammlungen häufig auf Tabellen, mit denen verschiedene Datenstrukturen wie Arrays erstellt werden.

Generisches für Iterator

Ein generischer für Iterator liefert die Schlüsselwertepaare von jedem Element in der Sammlung. Ein einfaches Beispiel ist unten angegeben.

array = {"Lua", "Tutorial"}

for key,value in ipairs(array) 
do
   print(key, value)
end

Wenn wir den obigen Code ausführen, erhalten wir die folgende Ausgabe:

1  Lua
2  Tutorial

Im obigen Beispiel wird die von Lua bereitgestellte Standard- Ipair- Iteratorfunktion verwendet.

In Lua verwenden wir Funktionen, um Iteratoren darzustellen. Basierend auf der Zustandserhaltung in diesen Iteratorfunktionen haben wir zwei Haupttypen -

• Staatenlose Iteratoren
• Stateful Iteratoren

Staatenlose Iteratoren

Unter dem Namen selbst können wir verstehen, dass diese Art von Iteratorfunktion keinen Status beibehält.

Lassen Sie uns nun ein Beispiel für die Erstellung eines eigenen Iterators mit einer einfachen Funktion sehen, mit der die Quadrate von gedruckt werden n Zahlen.

function square(iteratorMaxCount,currentNumber)

   if currentNumber<iteratorMaxCount
   then
      currentNumber = currentNumber+1
      return currentNumber, currentNumber*currentNumber
   end
	
end

for i,n in square,3,0
do
   print(i,n)
end

Wenn wir das obige Programm ausführen, erhalten wir die folgende Ausgabe.

1	1
2	4
3	9

Der obige Code kann leicht geändert werden, um die Funktionsweise von Ipairs von Iteratoren nachzuahmen . Es ist unten gezeigt.

function square(iteratorMaxCount,currentNumber)

   if currentNumber<iteratorMaxCount
   then
      currentNumber = currentNumber+1
      return currentNumber, currentNumber*currentNumber
   end
	
end

function squares(iteratorMaxCount)
   return square,iteratorMaxCount,0
end  

for i,n in squares(3)
do 
   print(i,n)
end

Wenn wir das obige Programm ausführen, erhalten wir die folgende Ausgabe.

1	1
2	4
3	9

Stateful Iteratoren

Das vorherige Beispiel für die Iteration mit Funktion behält den Status nicht bei. Bei jedem Aufruf der Funktion wird das nächste Element der Sammlung basierend auf einer zweiten an die Funktion gesendeten Variablen zurückgegeben. Um den Status des aktuellen Elements beizubehalten, werden Verschlüsse verwendet. Beim Schließen werden Variablenwerte über Funktionsaufrufe hinweg beibehalten. Um einen neuen Verschluss zu erstellen, erstellen wir zwei Funktionen, einschließlich des Verschlusses selbst und einer Fabrik, der Funktion, die den Verschluss erstellt.

Lassen Sie uns nun ein Beispiel für die Erstellung eines eigenen Iterators sehen, in dem wir Verschlüsse verwenden werden.

array = {"Lua", "Tutorial"}

function elementIterator (collection)

   local index = 0
   local count = #collection
	
   -- The closure function is returned
	
   return function ()
      index = index + 1
		
      if index <= count
      then
         -- return the current element of the iterator
         return collection[index]
      end
		
   end
	
end

for element in elementIterator(array)
do
   print(element)
end

Wenn wir das obige Programm ausführen, erhalten wir die folgende Ausgabe.

Lua
Tutorial

Im obigen Beispiel sehen wir, dass elementIterator eine andere Methode enthält, die den Index und die Anzahl der lokalen externen Variablen verwendet, um jedes Element in der Auflistung zurückzugeben, indem der Index bei jedem Aufruf der Funktion erhöht wird.

Wir können unsere eigenen Funktionsiteratoren mithilfe des oben gezeigten Abschlusses erstellen und für jede Zeit, in der wir die Sammlung durchlaufen, mehrere Elemente zurückgeben.

Einführung

Tabellen sind die einzige in Lua verfügbare Datenstruktur, mit deren Hilfe wir verschiedene Typen wie Arrays und Wörterbücher erstellen können. Lua verwendet assoziative Arrays, die nicht nur mit Zahlen, sondern auch mit Zeichenfolgen außer Null indiziert werden können. Tische haben keine feste Größe und können je nach Bedarf wachsen.

Lua verwendet Tabellen in allen Darstellungen, einschließlich der Darstellung von Paketen. Wenn wir auf eine Methode string.format zugreifen, bedeutet dies, dass wir auf die im String-Paket verfügbare Formatfunktion zugreifen.

Darstellung und Verwendung

Tabellen werden als Objekte bezeichnet und sind weder Werte noch Variablen. Lua verwendet einen Konstruktorausdruck {}, um eine leere Tabelle zu erstellen. Es ist bekannt, dass es keine feste Beziehung zwischen einer Variablen, die die Referenz der Tabelle enthält, und der Tabelle selbst gibt.

--sample table initialization
mytable = {}

--simple table value assignment
mytable[1]= "Lua"

--removing reference
mytable = nil

-- lua garbage collection will take care of releasing memory

Wenn wir einen Tisch haben a mit Satz von Elementen und wenn wir es zuweisen b, beide a und bbeziehen sich auf den gleichen Speicher. Für b wird kein separater Speicher separat zugewiesen. Wenn a auf Null gesetzt ist, ist die Tabelle weiterhin für b zugänglich. Wenn kein Verweis auf eine Tabelle vorhanden ist, übernimmt die Speicherbereinigung in Lua den Bereinigungsprozess, damit dieser nicht referenzierte Speicher wieder verwendet wird.

Im Folgenden wird ein Beispiel zur Erläuterung der oben genannten Funktionen von Tabellen gezeigt.

-- Simple empty table
mytable = {}
print("Type of mytable is ",type(mytable))

mytable[1]= "Lua"
mytable["wow"] = "Tutorial"

print("mytable Element at index 1 is ", mytable[1])
print("mytable Element at index wow is ", mytable["wow"])

-- alternatetable and mytable refers to same table
alternatetable = mytable

print("alternatetable Element at index 1 is ", alternatetable[1])
print("alternatetable Element at index wow is ", alternatetable["wow"])

alternatetable["wow"] = "I changed it"

print("mytable Element at index wow is ", mytable["wow"])

-- only variable released and and not table
alternatetable = nil
print("alternatetable is ", alternatetable)

-- mytable is still accessible
print("mytable Element at index wow is ", mytable["wow"])

mytable = nil
print("mytable is ", mytable)

Wenn wir das obige Programm ausführen, erhalten wir die folgende Ausgabe:

Type of mytable is 	table
mytable Element at index 1 is 	Lua
mytable Element at index wow is 	Tutorial
alternatetable Element at index 1 is 	Lua
alternatetable Element at index wow is 	Tutorial
mytable Element at index wow is 	I changed it
alternatetable is 	nil
mytable Element at index wow is 	I changed it
mytable is 	nil

Tabellenmanipulation

Es gibt integrierte Funktionen für die Tabellenmanipulation, die in der folgenden Tabelle aufgeführt sind.

Sr.Nr.	Methode & Zweck
1	table.concat (table [, sep [, i [, j]]]) Verkettet die Zeichenfolgen in den Tabellen basierend auf den angegebenen Parametern. Siehe Beispiel für Details.
2	table.insert (table, [pos,] value) Fügt an der angegebenen Position einen Wert in die Tabelle ein.
3	table.maxn (table) Gibt den größten numerischen Index zurück.
4	table.remove (table [, pos]) Entfernt den Wert aus der Tabelle.
5	table.sort (table [, comp]) Sortiert die Tabelle basierend auf dem optionalen Komparatorargument.

Lassen Sie uns einige Beispiele der oben genannten Funktionen sehen.

Tabellenverkettung

Wir können die concat-Funktion verwenden, um zwei Tabellen wie unten gezeigt zu verketten -

fruits = {"banana","orange","apple"}

-- returns concatenated string of table
print("Concatenated string ",table.concat(fruits))

--concatenate with a character
print("Concatenated string ",table.concat(fruits,", "))

--concatenate fruits based on index
print("Concatenated string ",table.concat(fruits,", ", 2,3))

Wenn wir das obige Programm ausführen, erhalten wir die folgende Ausgabe:

Concatenated string 	bananaorangeapple
Concatenated string 	banana, orange, apple
Concatenated string 	orange, apple

Einfügen und entfernen

Das Einfügen und Entfernen von Elementen in Tabellen ist bei der Tabellenmanipulation am häufigsten. Es wird unten erklärt.

fruits = {"banana","orange","apple"}

-- insert a fruit at the end
table.insert(fruits,"mango")
print("Fruit at index 4 is ",fruits[4])

--insert fruit at index 2
table.insert(fruits,2,"grapes")
print("Fruit at index 2 is ",fruits[2])

print("The maximum elements in table is",table.maxn(fruits))

print("The last element is",fruits[5])

table.remove(fruits)
print("The previous last element is",fruits[5])

Wenn wir das obige Programm ausführen, erhalten wir die folgende Ausgabe:

Fruit at index 4 is 	mango
Fruit at index 2 is 	grapes
The maximum elements in table is	5
The last element is	mango
The previous last element is	nil

Tabellen sortieren

Wir müssen häufig eine Tabelle in einer bestimmten Reihenfolge sortieren. Die Sortierfunktionen sortieren die Elemente in einer Tabelle alphabetisch. Ein Beispiel hierfür ist unten gezeigt.

fruits = {"banana","orange","apple","grapes"}

for k,v in ipairs(fruits) do
   print(k,v)
end

table.sort(fruits)
print("sorted table")

for k,v in ipairs(fruits) do
   print(k,v)
end

Wenn wir das obige Programm ausführen, erhalten wir die folgende Ausgabe:

1	banana
2	orange
3	apple
4	grapes
sorted table
1	apple
2	banana
3	grapes
4	orange

Was ist ein Modul?

Das Modul ist wie eine Bibliothek, die mit require geladen werden kann und einen einzigen globalen Namen hat, der eine Tabelle enthält. Dieses Modul kann aus einer Reihe von Funktionen und Variablen bestehen. Alle diese Funktionen und Variablen sind in die Tabelle eingebunden, die als Namespace fungiert. Ein gut erzogenes Modul verfügt auch über die erforderlichen Vorkehrungen, um diese Tabelle bei Bedarf zurückzugeben.

Spezialität der Lua-Module

Die Verwendung von Tabellen in Modulen hilft uns auf vielfältige Weise und ermöglicht es uns, die Module auf die gleiche Weise zu manipulieren, wie wir jede andere Lua-Tabelle manipulieren. Aufgrund der Möglichkeit, Module zu manipulieren, bietet es zusätzliche Funktionen, für die andere Sprachen spezielle Mechanismen benötigen. Aufgrund dieses freien Mechanismus von Modulen in Lua kann ein Benutzer die Funktionen in Lua auf verschiedene Arten aufrufen. Einige davon sind unten aufgeführt.

-- Assuming we have a module printFormatter
-- Also printFormatter has a funtion simpleFormat(arg)
-- Method 1
require "printFormatter"
printFormatter.simpleFormat("test")

-- Method 2
local formatter = require "printFormatter"
formatter.simpleFormat("test")

-- Method 3
require "printFormatter"
local formatterFunction = printFormatter.simpleFormat
formatterFunction("test")

Im obigen Beispielcode können Sie sehen, wie flexibel die Programmierung in Lua ohne speziellen zusätzlichen Code ist.

Die erfordern Funktion

Lua hat eine High-Level-Funktion namens require bereitgestellt , um alle erforderlichen Module zu laden. Es wird so einfach wie möglich gehalten, um zu vermeiden, dass zu viele Informationen zum Laden des Moduls vorliegen. Die Funktion require setzt die Module lediglich als Codeabschnitt voraus, der einige Werte definiert, dh Funktionen oder Tabellen, die Funktionen enthalten.

Beispiel

Betrachten wir ein einfaches Beispiel, in dem eine Funktion die mathematischen Funktionen hat. Nennen wir dieses Modul mymath und Dateiname mymath.lua. Der Dateiinhalt ist wie folgt:

local mymath =  {}

function mymath.add(a,b)
   print(a+b)
end

function mymath.sub(a,b)
   print(a-b)
end

function mymath.mul(a,b)
   print(a*b)
end

function mymath.div(a,b)
   print(a/b)
end

return mymath

Um auf dieses Lua-Modul in einer anderen Datei, z. B. moduletutorial.lua, zugreifen zu können, müssen Sie das folgende Codesegment verwenden.

mymathmodule = require("mymath")
mymathmodule.add(10,20)
mymathmodule.sub(30,20)
mymathmodule.mul(10,20)
mymathmodule.div(30,20)

Um diesen Code auszuführen, müssen wir die beiden Lua-Dateien im selben Verzeichnis ablegen. Alternativ können Sie die Moduldatei im Paketpfad ablegen und sie muss zusätzlich eingerichtet werden. Wenn wir das obige Programm ausführen, erhalten wir die folgende Ausgabe.

30
10
200
1.5

Dinge, an die man sich erinnern sollte

• Platzieren Sie sowohl die Module als auch die von Ihnen ausgeführte Datei im selben Verzeichnis.

• Der Modulname und sein Dateiname sollten identisch sein.

• Es wird empfohlen, Module für die erforderliche Funktion zurückzugeben. Daher sollte das Modul vorzugsweise wie oben gezeigt implementiert werden, obwohl Sie andere Arten von Implementierungen an anderer Stelle finden können.

Alte Art, Module zu implementieren

Lassen Sie mich jetzt dasselbe Beispiel auf ältere Weise umschreiben, wobei der Implementierungstyp package.seeall verwendet wird. Dies wurde in den Lua-Versionen 5.1 und 5.0 verwendet. Das mymath-Modul ist unten dargestellt.

module("mymath", package.seeall)

function mymath.add(a,b)
   print(a+b)
end

function mymath.sub(a,b)
   print(a-b)
end

function mymath.mul(a,b)
   print(a*b)
end

function mymath.div(a,b)
   print(a/b)
end

Die Verwendung von Modulen in moduletutorial.lua wird unten gezeigt.

require("mymath")
mymath.add(10,20)
mymath.sub(30,20)
mymath.mul(10,20)
mymath.div(30,20)

Wenn wir das oben genannte ausführen, erhalten wir die gleiche Ausgabe. Es wird jedoch empfohlen, die ältere Version des Codes zu verwenden, und es wird davon ausgegangen, dass er weniger sicher ist. Viele SDKs, die Lua zum Programmieren verwenden, wie das Corona SDK, haben die Verwendung dieses SDKs abgelehnt.

Eine Metatabelle ist eine Tabelle, mit deren Hilfe das Verhalten einer Tabelle, an die sie angehängt ist, mithilfe eines Schlüsselsatzes und zugehöriger Metamethoden geändert werden kann. Diese Metamethoden sind leistungsstarke Lua-Funktionen, die Funktionen wie - ermöglichen

• Ändern / Hinzufügen von Funktionen zu Operatoren in Tabellen.

• Nach Metatabellen suchen, wenn der Schlüssel in der Tabelle nicht verfügbar ist, mit __index in Metatabelle.

Es gibt zwei wichtige Methoden, die beim Umgang mit Metatables verwendet werden:

• setmetatable(table,metatable) - Mit dieser Methode wird die Metatabelle für eine Tabelle festgelegt.

• getmetatable(table) - Diese Methode wird verwendet, um die Metatierbarkeit einer Tabelle zu ermitteln.

Schauen wir uns zunächst an, wie eine Tabelle als Metatable einer anderen festgelegt wird. Es ist unten gezeigt.

mytable = {}
mymetatable = {}
setmetatable(mytable,mymetatable)

Der obige Code kann wie unten gezeigt in einer einzelnen Zeile dargestellt werden.

mytable = setmetatable({},{})

_Index

Ein einfaches Beispiel für eine Metatabelle zum Nachschlagen der Metatabelle, wenn sie nicht in der Tabelle verfügbar ist, ist unten dargestellt.

mytable = setmetatable({key1 = "value1"}, {
   __index = function(mytable, key)
	
      if key == "key2" then
         return "metatablevalue"
      else
         return mytable[key]
      end
   end
})

print(mytable.key1,mytable.key2)

Wenn wir das obige Programm ausführen, erhalten wir die folgende Ausgabe.

value1 metatablevalue

Lassen Sie uns in Schritten erklären, was im obigen Beispiel passiert ist.

• Die Tabelle hier ist {key1 = "value1"}.

• Metatable ist für mytable festgelegt, das eine Funktion für __index enthält, die wir als Metamethode aufrufen.

• Die Metamethode sucht auf einfache Weise nach einem Index "key2". Wenn er gefunden wird, gibt er "metatablevalue" zurück, andernfalls den Wert von mytable für den entsprechenden Index.

Wir können eine vereinfachte Version des obigen Programms haben, wie unten gezeigt.

mytable = setmetatable({key1 = "value1"}, 
   { __index = { key2 = "metatablevalue" } })
print(mytable.key1,mytable.key2)

__newindex

Wenn wir __newindex zu metatable hinzufügen und Schlüssel in der Tabelle nicht verfügbar sind, wird das Verhalten neuer Schlüssel durch Metamethoden definiert. Ein einfaches Beispiel, in dem der Index von metatable festgelegt wird, wenn der Index in der Haupttabelle nicht verfügbar ist, ist unten angegeben.

mymetatable = {}
mytable = setmetatable({key1 = "value1"}, { __newindex = mymetatable })

print(mytable.key1)

mytable.newkey = "new value 2"
print(mytable.newkey,mymetatable.newkey)

mytable.key1 = "new  value 1"
print(mytable.key1,mymetatable.newkey1)

Wenn Sie das obige Programm ausführen, erhalten Sie die folgende Ausgabe.

value1
nil	new value 2
new  value 1	nil

Sie können im obigen Programm sehen, dass ein Schlüssel, der in der Haupttabelle vorhanden ist, nur aktualisiert wird. Wenn ein Schlüssel in der Wartungsdatei nicht verfügbar ist, fügt er diesen Schlüssel der Metatabelle hinzu.

Ein weiteres Beispiel, das dieselbe Tabelle mithilfe der Rawset-Funktion aktualisiert, ist unten dargestellt.

mytable = setmetatable({key1 = "value1"}, {

   __newindex = function(mytable, key, value)
      rawset(mytable, key, "\""..value.."\"")
   end
})

mytable.key1 = "new value"
mytable.key2 = 4

print(mytable.key1,mytable.key2)

Wenn wir das obige Programm ausführen, erhalten wir die folgende Ausgabe.

new value	"4"

rawset legt den Wert fest, ohne __newindex von metatable zu verwenden. Ebenso gibt es ein Rawget, das Wert erhält, ohne __index zu verwenden.

Hinzufügen des Bedienerverhaltens zu Tabellen

Ein einfaches Beispiel zum Kombinieren von zwei Tabellen mit dem Operator + ist unten dargestellt.

mytable = setmetatable({ 1, 2, 3 }, {
   __add = function(mytable, newtable)
	
      for i = 1, table.maxn(newtable) do
         table.insert(mytable, table.maxn(mytable)+1,newtable[i])
      end
      return mytable
   end
})

secondtable = {4,5,6}

mytable = mytable + secondtable

for k,v in ipairs(mytable) do
   print(k,v)
end

Wenn wir das obige Programm ausführen, erhalten wir die folgende Ausgabe.

1	1
2	2
3	3
4	4
5	5
6	6

Der __add-Schlüssel ist in der Metatabelle enthalten, um das Verhalten von Operator + hinzuzufügen. Die Tabelle der Schlüssel und des entsprechenden Operators ist unten dargestellt.

Sr.Nr.	Modus & Beschreibung
1	__add Ändert das Verhalten des Operators '+'.
2	__sub Ändert das Verhalten des Operators '-'.
3	__mul Ändert das Verhalten des Operators '*'.
4	__div Ändert das Verhalten des Operators '/'.
5	__mod Ändert das Verhalten des Operators '%'.
6	__unm Ändert das Verhalten des Operators '-'.
7	__concat Ändert das Verhalten des Operators '..'.
8	__eq Ändert das Verhalten des Operators '=='.
9	__lt Ändert das Verhalten des Operators '<'.
10	__le Ändert das Verhalten des Operators '<='.

__Anruf

Das Hinzufügen des Verhaltens des Methodenaufrufs erfolgt mit der Anweisung __call. Ein einfaches Beispiel, das die Summe der Werte in der Haupttabelle mit der übergebenen Tabelle zurückgibt.

mytable = setmetatable({10}, {
   __call = function(mytable, newtable)
   sum = 0
	
      for i = 1, table.maxn(mytable) do
         sum = sum + mytable[i]
      end
	
      for i = 1, table.maxn(newtable) do
         sum = sum + newtable[i]
      end
	
      return sum
   end
})

newtable = {10,20,30}
print(mytable(newtable))

Wenn wir das obige Programm ausführen, erhalten wir die folgende Ausgabe.

70

__tostring

Um das Verhalten der print-Anweisung zu ändern, können wir die Metamethode __tostring verwenden. Ein einfaches Beispiel ist unten gezeigt.

mytable = setmetatable({ 10, 20, 30 }, {
   __tostring = function(mytable)
   sum = 0
	
      for k, v in pairs(mytable) do
         sum = sum + v
      end
		
      return "The sum of values in the table is " .. sum
   end
})
print(mytable)

Wenn wir das obige Programm ausführen, erhalten wir die folgende Ausgabe.

The sum of values in the table is 60

Wenn Sie die Funktionen der Metatabelle vollständig kennen, können Sie wirklich viele Operationen ausführen, die ohne ihre Verwendung sehr komplex wären. Versuchen Sie also, mehr über die Verwendung von Metatabellen mit verschiedenen Optionen in Metatabellen zu arbeiten, wie in den Beispielen erläutert, und erstellen Sie auch Ihre eigenen Beispiele.

Einführung

Coroutinen sind kollaborativer Natur, wodurch zwei oder mehr Methoden kontrolliert ausgeführt werden können. Bei Coroutinen wird zu einem bestimmten Zeitpunkt nur eine Coroutine ausgeführt, und diese laufende Coroutine setzt ihre Ausführung nur dann aus, wenn sie ausdrücklich die Unterbrechung anfordert.

Die obige Definition kann vage aussehen. Nehmen wir an, wir haben zwei Methoden, eine Hauptprogrammmethode und eine Coroutine. Wenn wir eine Coroutine mit der Resume-Funktion aufrufen, wird sie ausgeführt, und wenn wir die Yield-Funktion aufrufen, wird die Ausführung angehalten. Wiederum kann dieselbe Coroutine mit einem anderen Funktionsaufruf zur Wiederaufnahme fortgesetzt werden, von dem aus sie angehalten wurde. Dieser Vorgang kann bis zum Ende der Ausführung der Coroutine fortgesetzt werden.

In Coroutinen verfügbare Funktionen

In der folgenden Tabelle sind alle verfügbaren Funktionen für Coroutinen in Lua und ihre entsprechende Verwendung aufgeführt.

Sr.Nr.	Methode & Zweck
1	coroutine.create (f) Erstellt eine neue Coroutine mit der Funktion f und gibt ein Objekt vom Typ "thread" zurück.
2	coroutine.resume (co [, val1, ...]) Setzt die Coroutine co fort und übergibt die Parameter, falls vorhanden. Es gibt den Betriebsstatus und optional andere Rückgabewerte zurück.
3	coroutine.running () Gibt die laufende Coroutine oder Null zurück, wenn sie im Hauptthread aufgerufen wird.
4	coroutine.status (co) Gibt einen der Werte aus "Laufen", "Normal", "Angehalten" oder "Tot" zurück, basierend auf dem Status der Coroutine.
5	coroutine.wrap (f) Wie coroutine.create erstellt auch die Funktion coroutine.wrap eine Coroutine, aber anstatt die Coroutine selbst zurückzugeben, gibt sie eine Funktion zurück, die beim Aufruf die Coroutine wieder aufnimmt.
6	coroutine.yield (...) Hält die laufende Coroutine an. Der an diese Methode übergebene Parameter dient als zusätzliche Rückgabewerte für die Wiederaufnahmefunktion.

Beispiel

Schauen wir uns ein Beispiel an, um das Konzept der Coroutinen zu verstehen.

co = coroutine.create(function (value1,value2)
   local tempvar3 = 10
   print("coroutine section 1", value1, value2, tempvar3)
	
   local tempvar1 = coroutine.yield(value1+1,value2+1)
   tempvar3 = tempvar3 + value1
   print("coroutine section 2",tempvar1 ,tempvar2, tempvar3)
	
   local tempvar1, tempvar2= coroutine.yield(value1+value2, value1-value2)
   tempvar3 = tempvar3 + value1
   print("coroutine section 3",tempvar1,tempvar2, tempvar3)
   return value2, "end"
	
end)

print("main", coroutine.resume(co, 3, 2))
print("main", coroutine.resume(co, 12,14))
print("main", coroutine.resume(co, 5, 6))
print("main", coroutine.resume(co, 10, 20))

Wenn wir das obige Programm ausführen, erhalten wir die folgende Ausgabe.

coroutine section 1	3	2	10
main	true	4	3
coroutine section 2	12	nil	13
main	true	5	1
coroutine section 3	5	6	16
main	true	2	end
main	false	cannot resume dead coroutine

Was macht das obige Beispiel?

Wie bereits erwähnt, verwenden wir die Wiederaufnahmefunktion, um die Operation zu starten, und die Yield-Funktion, um die Operation zu stoppen. Sie können auch sehen, dass mehrere Rückgabewerte von der Wiederaufnahmefunktion von Coroutine empfangen werden.

• Zuerst erstellen wir eine Coroutine und weisen sie einem Variablennamen co zu. Die Coroutine nimmt zwei Variablen als Parameter auf.

• Wenn wir die erste Wiederaufnahmefunktion aufrufen, bleiben die Werte 3 und 2 in den temporären Variablen value1 und value2 bis zum Ende der Coroutine erhalten.

• Um dies zu verstehen, haben wir eine Tempvar3 verwendet, die anfänglich 10 ist und durch die nachfolgenden Aufrufe der Coroutinen auf 13 und 16 aktualisiert wird, da Wert1 während der Ausführung der Coroutine als 3 beibehalten wird.

• Die erste coroutine.yield gibt zwei Werte 4 und 3 an die Resume-Funktion zurück, die wir durch Aktualisieren der Eingabeparameter 3 und 2 in der Yield-Anweisung erhalten. Es erhält auch den True / False-Status der Coroutine-Ausführung.

• Eine andere Sache über Coroutinen ist, wie die nächsten Parameter des Wiederaufnahmeaufrufs im obigen Beispiel erledigt werden; Sie können sehen, dass die Variable coroutine.yield die nächsten Aufrufparameter empfängt. Dies bietet eine leistungsstarke Möglichkeit, neue Operationen unter Beibehaltung vorhandener Parameterwerte durchzuführen.

• Sobald alle Anweisungen in den Coroutinen ausgeführt wurden, werden die nachfolgenden Aufrufe in false zurückgegeben und die Anweisung "tote Coroutine kann nicht fortgesetzt werden" als Antwort.

Ein weiteres Coroutine-Beispiel

Betrachten wir eine einfache Coroutine, die mit Hilfe der Ertragsfunktion und der Wiederaufnahmefunktion eine Zahl von 1 bis 5 zurückgibt. Es erstellt eine Coroutine, wenn diese nicht verfügbar ist, oder setzt die vorhandene Coroutine fort.

function getNumber()
   local function getNumberHelper()
      co = coroutine.create(function ()
      coroutine.yield(1)
      coroutine.yield(2)
      coroutine.yield(3)
      coroutine.yield(4)
      coroutine.yield(5)
      end)
      return co
   end
	
   if(numberHelper) then
      status, number = coroutine.resume(numberHelper);
		
      if coroutine.status(numberHelper) == "dead" then
         numberHelper = getNumberHelper()
         status, number = coroutine.resume(numberHelper);
      end
		
      return number
   else
      numberHelper = getNumberHelper()
      status, number = coroutine.resume(numberHelper);
      return number
   end
	
end

for index = 1, 10 do
   print(index, getNumber())
end

Wenn wir das obige Programm ausführen, erhalten wir die folgende Ausgabe.

1	1
2	2
3	3
4	4
5	5
6	1
7	2
8	3
9	4
10	5

Es gibt oft einen Vergleich von Coroutinen mit den Threads von Multiprogrammiersprachen, aber wir müssen verstehen, dass Coroutinen ähnliche Thread-Funktionen haben, aber jeweils nur eine ausführen und niemals gleichzeitig ausgeführt werden.

Wir steuern die Programmausführungssequenz, um die Anforderungen zu erfüllen, indem bestimmte Informationen vorübergehend aufbewahrt werden. Die Verwendung globaler Variablen mit Coroutinen bietet Coroutinen noch mehr Flexibilität.

Die E / A-Bibliothek wird zum Lesen und Bearbeiten von Dateien in Lua verwendet. In Lua gibt es zwei Arten von Dateivorgängen, nämlich implizite Dateideskriptoren und explizite Dateideskriptoren.

Für die folgenden Beispiele verwenden wir eine Beispieldatei test.lua, wie unten gezeigt.

-- sample test.lua
-- sample2 test.lua

Ein einfacher Vorgang zum Öffnen von Dateien verwendet die folgende Anweisung.

file = io.open (filename [, mode])

Die verschiedenen Dateimodi sind in der folgenden Tabelle aufgeführt.

Sr.Nr.	Modus & Beschreibung
1	"r" Schreibgeschützter Modus und ist der Standardmodus, in dem eine vorhandene Datei geöffnet wird.
2	"w" Schreibaktivierter Modus, der die vorhandene Datei überschreibt oder eine neue Datei erstellt.
3	"a" Anhänge-Modus, der eine vorhandene Datei öffnet oder eine neue Datei zum Anhängen erstellt.
4	"r+" Lese- und Schreibmodus für eine vorhandene Datei.
5	"w+" Alle vorhandenen Daten werden entfernt, wenn eine Datei vorhanden ist oder eine neue Datei mit Lese- / Schreibberechtigungen erstellt wird.
6	"a+" Anhänge-Modus mit aktiviertem Lesemodus, der eine vorhandene Datei öffnet oder eine neue Datei erstellt.

Implizite Dateideskriptoren

Implizite Dateideskriptoren verwenden die Standardeingabe- / Ausgabemodi oder eine einzelne Eingabe- und eine einzelne Ausgabedatei. Ein Beispiel für die Verwendung impliziter Dateideskriptoren ist unten dargestellt.

-- Opens a file in read
file = io.open("test.lua", "r")

-- sets the default input file as test.lua
io.input(file)

-- prints the first line of the file
print(io.read())

-- closes the open file
io.close(file)

-- Opens a file in append mode
file = io.open("test.lua", "a")

-- sets the default output file as test.lua
io.output(file)

-- appends a word test to the last line of the file
io.write("-- End of the test.lua file")

-- closes the open file
io.close(file)

Wenn Sie das Programm ausführen, erhalten Sie eine Ausgabe der ersten Zeile der Datei test.lua. Für unser Programm haben wir die folgende Ausgabe erhalten.

-- Sample test.lua

Dies war für uns die erste Zeile der Anweisung in der Datei test.lua. Auch die Zeile "- Ende der Datei test.lua" wird an die letzte Zeile des Codes test.lua angehängt.

Im obigen Beispiel können Sie sehen, wie die impliziten Deskriptoren mit dem Dateisystem mithilfe der io. "X" -Methoden funktionieren. Im obigen Beispiel wird io.read () ohne den optionalen Parameter verwendet. Der optionale Parameter kann einer der folgenden sein.

Sr.Nr.	Modus & Beschreibung
1	"*n" Liest von der aktuellen Dateiposition und gibt eine Zahl zurück, wenn diese an der Dateiposition vorhanden ist, oder gibt null zurück.
2	"*a" Gibt den gesamten Inhalt der Datei von der aktuellen Dateiposition zurück.
3	"*l" Liest die Zeile von der aktuellen Dateiposition und verschiebt die Dateiposition in die nächste Zeile.
4	number Liest die Anzahl der in der Funktion angegebenen Bytes.

Andere gängige E / A-Methoden umfassen:

• io.tmpfile() - Gibt eine temporäre Datei zum Lesen und Schreiben zurück, die nach dem Beenden des Programms entfernt wird.

• io.type(file) - Gibt basierend auf der Eingabedatei zurück, ob Datei, geschlossene Datei oder Null.

• io.flush() - Löscht den Standardausgabepuffer.

• io.lines(optional file name)- Bietet einen generischen for- Schleifeniterator, der die Datei durchläuft und die Datei am Ende schließt, falls der Dateiname angegeben wird oder die Standarddatei verwendet wird und am Ende der Schleife nicht geschlossen wird.

Explizite Dateideskriptoren

Wir verwenden häufig einen expliziten Dateideskriptor, mit dem wir mehrere Dateien gleichzeitig bearbeiten können. Diese Funktionen sind impliziten Dateideskriptoren sehr ähnlich. Hier verwenden wir file: function_name anstelle von io.function_name. Das folgende Beispiel für die Dateiversion desselben Beispiels für implizite Dateideskriptoren ist unten dargestellt.

-- Opens a file in read mode
file = io.open("test.lua", "r")

-- prints the first line of the file
print(file:read())

-- closes the opened file
file:close()

-- Opens a file in append mode
file = io.open("test.lua", "a")

-- appends a word test to the last line of the file
file:write("--test")

-- closes the open file
file:close()

Wenn Sie das Programm ausführen, erhalten Sie eine ähnliche Ausgabe wie im Beispiel für implizite Deskriptoren.

-- Sample test.lua

Alle Modi zum Öffnen von Dateien und zum Lesen für externe Deskriptoren sind dieselben wie bei impliziten Dateideskriptoren.

Andere gängige Dateimethoden umfassen:

• file:seek(optional whence, optional offset)- Woher Parameter ist "gesetzt", "cur" oder "end". Legt den neuen Dateizeiger mit der aktualisierten Dateiposition vom Anfang der Datei an fest. Die Offsets basieren in dieser Funktion auf Null. Der Versatz wird vom Anfang der Datei an gemessen, wenn das erste Argument "gesetzt" ist. von der aktuellen Position in der Datei, wenn es "cur" ist; oder vom Ende der Datei, wenn es "Ende" ist. Die Standardargumentwerte sind "cur" und 0, sodass die aktuelle Dateiposition durch Aufrufen dieser Funktion ohne Argumente ermittelt werden kann.

• file:flush() - Löscht den Standardausgabepuffer.

• io.lines(optional file name)- Bietet einen generischen for- Schleifeniterator, der die Datei durchläuft und die Datei am Ende schließt, falls der Dateiname angegeben wird oder die Standarddatei verwendet wird und am Ende der Schleife nicht geschlossen wird.

Ein Beispiel für die Verwendung der Suchmethode ist unten dargestellt. Es versetzt den Cursor von den 25 Positionen vor dem Dateiende. Die Lesefunktion druckt den Rest der Datei aus der Suchposition.

-- Opens a file in read
file = io.open("test.lua", "r")

file:seek("end",-25)
print(file:read("*a"))

-- closes the opened file
file:close()

Sie erhalten eine Ausgabe ähnlich der folgenden.

sample2 test.lua
--test

Sie können alle verschiedenen Modi und Parameter ausprobieren, um die volle Leistungsfähigkeit der Lua-Dateivorgänge zu kennen.

Notwendigkeit der Fehlerbehandlung

Die Fehlerbehandlung ist sehr kritisch, da für reale Vorgänge häufig komplexe Vorgänge erforderlich sind, darunter Dateivorgänge, Datenbanktransaktionen und Webdienstaufrufe.

Bei jeder Programmierung ist immer eine Fehlerbehandlung erforderlich. Es gibt zwei Arten von Fehlern:

• Syntaxfehler
• Laufzeitfehler

Syntaxfehler

Syntaxfehler treten auf, wenn verschiedene Programmkomponenten wie Operatoren und Ausdrücke nicht ordnungsgemäß verwendet werden. Ein einfaches Beispiel für einen Syntaxfehler ist unten dargestellt.

a == 2

Wie Sie wissen, gibt es einen Unterschied zwischen der Verwendung eines einfachen "gleich" und eines doppelten "gleich". Die Verwendung eines anstelle des anderen kann zu einem Fehler führen. Ein "gleich" bezieht sich auf die Zuordnung, während sich ein doppeltes "gleich" auf den Vergleich bezieht. Ebenso haben wir Ausdrücke und Funktionen mit vordefinierten Implementierungsmethoden.

Ein weiteres Beispiel für einen Syntaxfehler ist unten dargestellt.

for a= 1,10
   print(a)
end

Wenn wir das obige Programm ausführen, erhalten wir die folgende Ausgabe:

lua: test2.lua:2: 'do' expected near 'print'

Syntaxfehler sind viel einfacher zu behandeln als Laufzeitfehler, da der Lua-Interpreter den Fehler klarer lokalisiert als bei Laufzeitfehlern. Aus dem obigen Fehler können wir leicht erkennen, dass das Hinzufügen einer do- Anweisung vor der print-Anweisung gemäß der Lua-Struktur erforderlich ist.

Laufzeitfehler

Bei Laufzeitfehlern wird das Programm erfolgreich ausgeführt, es kann jedoch zu Laufzeitfehlern aufgrund von Fehlern bei der Eingabe oder bei fehlerhaften Funktionen kommen. Ein einfaches Beispiel zum Anzeigen eines Laufzeitfehlers ist unten dargestellt.

function add(a,b)
   return a+b
end

add(10)

Wenn wir das Programm erstellen, wird es erfolgreich erstellt und ausgeführt. Sobald es ausgeführt wird, wird ein Laufzeitfehler angezeigt.

lua: test2.lua:2: attempt to perform arithmetic on local 'b' (a nil value)
stack traceback:
	test2.lua:2: in function 'add'
	test2.lua:5: in main chunk
	[C]: ?

Dies ist ein Laufzeitfehler, der aufgetreten ist, weil zwei Variablen nicht übergeben wurden. Dasb Parameter wird erwartet und hier ist es Null und erzeugt einen Fehler.

Assert- und Fehlerfunktionen

Um Fehler zu behandeln, verwenden wir häufig zwei Funktionen - assert und error. Ein einfaches Beispiel ist unten gezeigt.

local function add(a,b)
   assert(type(a) == "number", "a is not a number")
   assert(type(b) == "number", "b is not a number")
   return a+b
end

add(10)

Wenn wir das obige Programm ausführen, erhalten wir die folgende Fehlerausgabe.

lua: test2.lua:3: b is not a number
stack traceback:
	[C]: in function 'assert'
	test2.lua:3: in function 'add'
	test2.lua:6: in main chunk
	[C]: ?

Das error (message [, level])Beendet die zuletzt aufgerufene geschützte Funktion und gibt die Nachricht als Fehlermeldung zurück. Dieser Funktionsfehler wird nie zurückgegeben. Normalerweise fügt error am Anfang der Nachricht einige Informationen zur Fehlerposition hinzu. Das Argument level gibt an, wie die Fehlerposition ermittelt wird. Bei Stufe 1 (Standardeinstellung) wurde an der Fehlerposition die Fehlerfunktion aufgerufen. Stufe 2 zeigt den Fehler an die Stelle, an der die Funktion aufgerufen wurde, die den Fehler aufgerufen hat. und so weiter. Durch das Übergeben einer Stufe 0 wird das Hinzufügen von Fehlerpositionsinformationen zur Nachricht vermieden.

pcall und xpcall

In der Lua-Programmierung müssen wir die Funktionen pcall oder xpcall verwenden, um zu vermeiden, dass diese Fehler ausgelöst und Fehler behandelt werden.

Das pcall (f, arg1, ...)Funktion ruft die angeforderte Funktion im geschützten Modus auf. Wenn in Funktion f ein Fehler auftritt, wird kein Fehler ausgegeben. Es wird nur der Fehlerstatus zurückgegeben. Ein einfaches Beispiel für die Verwendung von pcall ist unten dargestellt.

function myfunction ()
   n = n/nil
end

if pcall(myfunction) then
   print("Success")
else
	print("Failure")
end

Wenn wir das obige Programm ausführen, erhalten wir die folgende Ausgabe.

Failure

Das xpcall (f, err)Funktion ruft die angeforderte Funktion auf und setzt auch den Fehlerbehandler. Ein Fehler in f wird nicht weitergegeben. Stattdessen fängt xpcall den Fehler ab, ruft die Fehlerfunktion mit dem ursprünglichen Fehlerobjekt auf und gibt einen Statuscode zurück.

Ein einfaches Beispiel für xpcall ist unten dargestellt.

function myfunction ()
   n = n/nil
end

function myerrorhandler( err )
   print( "ERROR:", err )
end

status = xpcall( myfunction, myerrorhandler )
print( status)

Wenn wir das obige Programm ausführen, erhalten wir die folgende Ausgabe.

ERROR:	test2.lua:2: attempt to perform arithmetic on global 'n' (a nil value)
false

Als Programmierer ist es äußerst wichtig, dass Sie in den von Ihnen geschriebenen Programmen für eine ordnungsgemäße Fehlerbehandlung sorgen. Durch die Verwendung der Fehlerbehandlung kann sichergestellt werden, dass unerwartete Bedingungen außerhalb der Randbedingungen behandelt werden, ohne den Benutzer des Programms zu stören.

Lua bietet eine Debug-Bibliothek, die alle primitiven Funktionen zum Erstellen eines eigenen Debuggers bietet. Obwohl es keinen eingebauten Lua-Debugger gibt, haben wir viele Debugger für Lua, die von verschiedenen Entwicklern erstellt wurden, von denen viele Open Source sind.

Die in der Lua-Debugbibliothek verfügbaren Funktionen sind in der folgenden Tabelle zusammen mit ihren Verwendungszwecken aufgeführt.

Sr.Nr.	Methode & Zweck
1	debug() Aktiviert den interaktiven Debugging-Modus, der aktiv bleibt, bis wir nur noch cont in eine Zeile eingeben und die Eingabetaste drücken. Der Benutzer kann Variablen in diesem Modus mit anderen Funktionen überprüfen.
2	getfenv(object) Gibt die Umgebung des Objekts zurück.
3	gethook(optional thread) Gibt die aktuellen Hook-Einstellungen des Threads als drei Werte zurück - die aktuelle Hook-Funktion, die aktuelle Hook-Maske und die aktuelle Hook-Anzahl.
4	getinfo(optional thread, function or stack level, optional flag) Gibt eine Tabelle mit Informationen zu einer Funktion zurück. Sie können die Funktion direkt angeben, oder Sie können eine Zahl als Wert der Funktion angeben. Dies bedeutet, dass die Funktion, die auf der Ebenenfunktion des Aufrufstapels des angegebenen Threads ausgeführt wird - Ebene 0 ist die aktuelle Funktion (getinfo selbst). Level 1 ist die Funktion, die getinfo aufgerufen hat. und so weiter. Wenn function eine Zahl ist, die größer als die Anzahl der aktiven Funktionen ist, gibt getinfo nil zurück.
5	getlocal(optional thread, stack level, local index) Gibt den Namen und den Wert der lokalen Variablen mit dem lokalen Index der Funktion auf der Ebene des Stapels zurück. Gibt null zurück, wenn der angegebene Index keine lokale Variable enthält, und löst einen Fehler aus, wenn eine Ebene außerhalb des Bereichs aufgerufen wird.
6	getmetatable(value) Gibt die Metatabelle des angegebenen Objekts oder Null zurück, wenn keine Metatabelle vorhanden ist.
7	getregistry() Gibt die Registrierungstabelle zurück, eine vordefinierte Tabelle, die von jedem C-Code verwendet werden kann, um den zu speichernden Lua-Wert zu speichern.
8	getupvalue(function, upvalue index) Diese Funktion gibt den Namen und den Wert des Upvalue mit dem Index up der Funktion func zurück. Die Funktion gibt nil zurück, wenn der angegebene Index keinen Aufwärtswert aufweist.
9	setfenv(function or thread or userdata, environment table) Legt die Umgebung des angegebenen Objekts auf die angegebene Tabelle fest. Gibt das Objekt zurück.
10	sethook(optional thread, hook function, hook mask string with "c" and/or "r" and/or "l", optional instruction count) Legt die angegebene Funktion als Hook fest. Die String-Maske und die Anzahl der Nummern beschreiben, wann der Hook aufgerufen wird. Hier werden c, r und l jedes Mal aufgerufen, wenn Lua jede Codezeile in einer Funktion aufruft, zurückgibt und eingibt.
11	setlocal(optional thread, stack level, local index, value) Weist den Wert der lokalen Variablen mit dem Index local der Funktion auf Stapelebene zu. Die Funktion gibt nil zurück, wenn es keine lokale Variable mit dem angegebenen Index gibt, und löst einen Fehler aus, wenn sie mit einer Ebene außerhalb des Bereichs aufgerufen wird. Andernfalls wird der Name der lokalen Variablen zurückgegeben.
12	setmetatable(value, metatable) Legt die Metatabelle für das angegebene Objekt auf die angegebene Tabelle fest (die Null sein kann).
13	setupvalue(function, upvalue index, value) Diese Funktion weist den Wert dem Aufwärtswert mit dem Index der Funktionsfunktion zu. Die Funktion gibt nil zurück, wenn der angegebene Index keinen Aufwärtswert aufweist. Andernfalls wird der Name des Upvalue zurückgegeben.
14	traceback(optional thread, optional message string, optional level argument) Erstellt eine erweiterte Fehlermeldung mit einem Traceback.

Die obige Liste ist die vollständige Liste der Debug-Funktionen in Lua. Wir verwenden häufig eine Bibliothek, die die oben genannten Funktionen verwendet und das Debuggen erleichtert. Die Verwendung dieser Funktionen und das Erstellen eines eigenen Debuggers ist recht kompliziert und nicht vorzuziehen. Wie auch immer, wir werden ein Beispiel für die einfache Verwendung von Debugging-Funktionen sehen.

function myfunction ()
   print(debug.traceback("Stack trace"))
   print(debug.getinfo(1))
   print("Stack trace end")

   return 10
end

myfunction ()
print(debug.getinfo(1))

Wenn wir das obige Programm ausführen, erhalten wir den Stack-Trace wie unten gezeigt.

Stack trace
stack traceback:
	test2.lua:2: in function 'myfunction'
	test2.lua:8: in main chunk
	[C]: ?
table: 0054C6C8
Stack trace end

Im obigen Beispielprogramm wird der Stack-Trace mithilfe der in der Debug-Bibliothek verfügbaren Funktion debug.trace gedruckt. Die debug.getinfo ruft die aktuelle Tabelle der Funktion ab.

Debugging - Beispiel

Wir müssen oft die lokalen Variablen einer Funktion zum Debuggen kennen. Zu diesem Zweck können wir getupvalue verwenden und um diese lokalen Variablen festzulegen, verwenden wir setupvalue. Ein einfaches Beispiel hierfür ist unten dargestellt.

function newCounter ()
   local n = 0
   local k = 0
	
   return function ()
      k = n
      n = n + 1
      return n
   end
	
end

counter = newCounter ()

print(counter())
print(counter())

local i = 1

repeat
   name, val = debug.getupvalue(counter, i)
	
   if name then
      print ("index", i, name, "=", val)
		
      if(name == "n") then
         debug.setupvalue (counter,2,10)
      end
		
      i = i + 1
   end -- if
	
until not name

print(counter())

Wenn wir das obige Programm ausführen, erhalten wir die folgende Ausgabe.

1
2
index	1	k	=	1
index	2	n	=	2
11

In diesem Beispiel wird der Zähler bei jedem Aufruf um eins aktualisiert. Mit der Funktion getupvalue können wir den aktuellen Status der lokalen Variablen anzeigen. Wir setzen dann die lokale Variable auf einen neuen Wert. Hier ist n 2, bevor die eingestellte Operation aufgerufen wird. Mit der Setupvalue-Funktion wird sie auf 10 aktualisiert. Wenn wir nun die Zählerfunktion aufrufen, wird 11 anstelle von 3 zurückgegeben.

Debugging-Typen

• Befehlszeilen-Debugging
• Grafisches Debuggen

Befehlszeilen-Debugging

Befehlszeilen-Debugging ist die Art des Debuggens, bei der mithilfe der Befehlszeile mithilfe von Befehlen und Druckanweisungen debuggt wird. Es gibt viele Befehlszeilen-Debugger für Lua, von denen einige unten aufgeführt sind.

• RemDebug- RemDebug ist ein Remote-Debugger für Lua 5.0 und 5.1. Damit können Sie die Ausführung eines anderen Lua-Programms fernsteuern, Haltepunkte setzen und den aktuellen Status des Programms überprüfen. RemDebug kann auch CGILua-Skripte debuggen.

• clidebugger- Ein einfacher Debugger für die Befehlszeilenschnittstelle für Lua 5.1, geschrieben in reinem Lua. Es ist von nichts anderem als den Standard-Lua 5.1-Bibliotheken abhängig. Es wurde von RemDebug inspiriert, verfügt jedoch nicht über Remote-Einrichtungen.

• ctrace - Ein Tool zum Verfolgen von Lua-API-Aufrufen.

• xdbLua - Ein einfacher Lua-Befehlszeilen-Debugger für die Windows-Plattform.

• LuaInterface - Debugger- Dieses Projekt ist eine Debugger-Erweiterung für LuaInterface. Dadurch wird die integrierte Lua-Debug-Oberfläche auf ein höheres Niveau angehoben. Die Interaktion mit dem Debugger erfolgt über Ereignisse und Methodenaufrufe.

• Rldb- Dies ist ein Remote-Lua-Debugger über Socket, der sowohl unter Windows als auch unter Linux verfügbar ist. Es kann Ihnen viel mehr Funktionen bieten als alle vorhandenen.

• ModDebug - Auf diese Weise können Sie die Ausführung eines anderen Lua-Programms fernsteuern, Haltepunkte setzen und den aktuellen Status des Programms überprüfen.

Grafisches Debuggen

Das grafische Debuggen ist mithilfe der IDE verfügbar, mit der Sie verschiedene Zustände wie Variablenwerte, Stapelverfolgung und andere verwandte Informationen visuell debuggen können. Es gibt eine visuelle Darstellung und schrittweise Steuerung der Ausführung mit Hilfe von Haltepunkten, Step-In, Step-Over und anderen Schaltflächen in der IDE.

Es gibt eine Reihe von grafischen Debuggern für Lua, darunter die folgenden.

• SciTE - Die Standard-Windows-IDE für Lua bietet mehrere Debugging-Funktionen wie Haltepunkte, Schritt, Schritt in, Schritt über, Überwachen von Variablen usw.

• Decoda - Dies ist ein grafischer Debugger mit Remote-Debugging-Unterstützung.

• ZeroBrane Studio- Lua IDE mit integriertem Remote-Debugger, Stapelansicht, Überwachungsansicht, Remote-Konsole, statischem Analysator und mehr. Funktioniert mit LuaJIT-, Love2d-, Moai- und anderen Lua-Motoren. Windows, OSX und Linux. Open Source.

• akdebugger - Debugger und Editor Lua Plugin für Eclipse.

• luaedit - Dies umfasst Remote-Debugging, lokales Debugging, Syntaxhervorhebung, Liste der Abschlussvorschläge, Parameter-Proposition-Engine, erweiterte Haltepunktverwaltung (einschließlich Bedingungssystem für Haltepunkte und Trefferanzahl), Funktionsliste, globale und lokale Variablenliste, Uhren, lösungsorientierte Verwaltung.

Lua verwendet die automatische Speicherverwaltung, die die Speicherbereinigung basierend auf bestimmten in Lua integrierten Algorithmen verwendet. Als Ergebnis der automatischen Speicherverwaltung als Entwickler -

• Sie müssen sich keine Gedanken über die Zuweisung von Speicher für Objekte machen.
• Sie müssen sie nicht freigeben, wenn sie nicht mehr benötigt werden, außer wenn Sie sie auf Null setzen.

Lua verwendet einen Garbage Collector, der von Zeit zu Zeit ausgeführt wird, um tote Objekte zu sammeln, auf die über das Lua-Programm nicht mehr zugegriffen werden kann.

Alle Objekte, einschließlich Tabellen, Benutzerdaten, Funktionen, Thread, Zeichenfolge usw., unterliegen einer automatischen Speicherverwaltung. Lua verwendet einen inkrementellen Markierungs- und Sweep-Kollektor, der zwei Zahlen verwendet, um seine Speicherbereinigungszyklen zu steuern, nämlichgarbage collector pause und garbage collector step multiplier. Diese Werte sind in Prozent angegeben und der Wert 100 ist intern häufig gleich 1.

Garbage Collector Pause

Die Garbage Collector-Pause wird verwendet, um zu steuern, wie lange der Garbage Collector vorher warten muss. Es wird erneut von der automatischen Speicherverwaltung des Lua aufgerufen. Werte unter 100 würden bedeuten, dass Lua nicht auf den nächsten Zyklus wartet. In ähnlicher Weise würden höhere Werte dieses Wertes dazu führen, dass der Garbage Collector langsam und weniger aggressiv ist. Ein Wert von 200 bedeutet, dass der Kollektor darauf wartet, dass sich der verwendete Gesamtspeicher verdoppelt, bevor er einen neuen Zyklus startet. Abhängig von der Art und Geschwindigkeit der Anwendung kann es daher erforderlich sein, diesen Wert zu ändern, um die beste Leistung in Lua-Anwendungen zu erzielen.

Garbage Collector Step Multiplikator

Dieser Schrittmultiplikator steuert die relative Geschwindigkeit des Garbage Collector zu der Speicherzuweisung im Lua-Programm. Größere Schrittwerte führen dazu, dass der Garbage Collector aggressiver wird, und erhöhen außerdem die Schrittgröße jedes inkrementellen Schritts der Garbage Collection. Werte unter 100 können häufig dazu führen, dass der Garbage Collector seinen Zyklus nicht abschließt und im Allgemeinen nicht bevorzugt wird. Der Standardwert ist 200, was bedeutet, dass der Garbage Collector doppelt so schnell ausgeführt wird wie die Speicherzuweisung.

Garbage Collector-Funktionen

Als Entwickler haben wir eine gewisse Kontrolle über die automatische Speicherverwaltung in Lua. Dafür haben wir folgende Methoden.

• collectgarbage("collect") - Führt einen vollständigen Zyklus der Speicherbereinigung aus.

• collectgarbage("count") - Gibt die derzeit vom Programm verwendete Speichermenge in Kilobyte zurück.

• collectgarbage("restart") - Wenn der Garbage Collector gestoppt wurde, wird er neu gestartet.

• collectgarbage("setpause")- Legt den als zweiten Parameter angegebenen Wert geteilt durch 100 für die Pausenvariable des Garbage Collector fest. Seine Verwendung ist wie oben beschrieben.

• collectgarbage("setstepmul")- Setzt den als zweiten Parameter angegebenen Wert geteilt durch 100 auf die Müllschritt-Multiplikatorvariable. Seine Verwendung ist wie oben beschrieben.

• collectgarbage("step")- Führt einen Schritt der Speicherbereinigung aus. Je größer das zweite Argument ist, desto größer wird dieser Schritt sein. Der Collectgarbage gibt true zurück, wenn der ausgelöste Schritt der letzte Schritt eines Garbage Collection-Zyklus war.

• collectgarbage("stop") - Stoppt den Garbage Collector, wenn er ausgeführt wird.

Ein einfaches Beispiel mit dem Garbage Collector-Beispiel ist unten dargestellt.

mytable = {"apple", "orange", "banana"}

print(collectgarbage("count"))

mytable = nil

print(collectgarbage("count"))

print(collectgarbage("collect"))

print(collectgarbage("count"))

Wenn wir das obige Programm ausführen, erhalten wir die folgende Ausgabe. Bitte beachten Sie, dass dieses Ergebnis aufgrund des unterschiedlichen Betriebssystemtyps und der automatischen Speicherverwaltungsfunktion von Lua unterschiedlich sein wird.

23.1455078125   149
23.2880859375   295
0
22.37109375     380

Sie können im obigen Programm sehen, dass nach Abschluss der Speicherbereinigung der verwendete Speicher reduziert wurde. Es ist jedoch nicht zwingend erforderlich, dies zu nennen. Auch wenn wir sie nicht aufrufen, wird sie zu einem späteren Zeitpunkt automatisch vom Lua-Interpreter nach der vordefinierten Zeit ausgeführt.

Natürlich können wir das Verhalten des Garbage Collectors mithilfe dieser Funktionen bei Bedarf ändern. Diese Funktionen bieten dem Entwickler zusätzliche Funktionen für komplexe Situationen. Abhängig von der Art des für das Programm benötigten Speichers können Sie diese Funktion verwenden oder nicht. Es ist jedoch sehr nützlich, die Speichernutzung in den Anwendungen zu kennen und diese während der Programmierung selbst zu überprüfen, um unerwünschte Ergebnisse nach der Bereitstellung zu vermeiden.

Einführung in OOP

Die objektorientierte Programmierung (OOP) ist eine der am häufigsten verwendeten Programmiertechniken, die in der modernen Ära der Programmierung verwendet wird. Es gibt eine Reihe von Programmiersprachen, die OOP unterstützen, darunter:

• C++
• Java
• Objective-C
• Smalltalk
• C#
• Ruby

Merkmale von OOP

• Class - Eine Klasse ist eine erweiterbare Vorlage zum Erstellen von Objekten, die Anfangswerte für den Status (Elementvariablen) und Verhaltensimplementierungen bereitstellt.

• Objects - Es ist eine Instanz der Klasse und hat einen separaten Speicher für sich.

• Inheritance - Es ist ein Konzept, nach dem Variablen und Funktionen einer Klasse von einer anderen Klasse geerbt werden.

• Encapsulation- Es ist der Prozess des Kombinierens der Daten und Funktionen innerhalb einer Klasse. Auf Daten kann außerhalb der Klasse mit Hilfe von Funktionen zugegriffen werden. Es wird auch als Datenabstraktion bezeichnet.

OOP in Lua

Sie können die Objektorientierung in Lua mithilfe von Tabellen und erstklassigen Funktionen von Lua implementieren. Durch Platzieren von Funktionen und zugehörigen Daten in einer Tabelle wird ein Objekt gebildet. Die Vererbung kann mithilfe von Metatabellen implementiert werden und bietet einen Suchmechanismus für nicht vorhandene Funktionen (Methoden) und Felder in übergeordneten Objekten.

Tabellen in Lua haben die Merkmale von Objekten wie Zustand und Identität, die unabhängig von ihren Werten sind. Zwei Objekte (Tabellen) mit demselben Wert sind unterschiedliche Objekte, während ein Objekt zu unterschiedlichen Zeiten unterschiedliche Werte haben kann, aber immer dasselbe Objekt ist. Wie Objekte haben Tabellen einen Lebenszyklus, der unabhängig davon ist, wer sie erstellt hat oder wo sie erstellt wurden.

Ein Beispiel aus der realen Welt

Das Konzept der Objektorientierung ist weit verbreitet, aber Sie müssen es klar verstehen, um einen angemessenen und maximalen Nutzen zu erzielen.

Betrachten wir ein einfaches mathematisches Beispiel. Wir begegnen oft Situationen, in denen wir an verschiedenen Formen wie Kreis, Rechteck und Quadrat arbeiten.

Die Formen können einen gemeinsamen Eigenschaftsbereich haben. So können wir andere Formen von der Basisobjektform mit dem gemeinsamen Eigenschaftsbereich erweitern. Jede der Formen kann ihre eigenen Eigenschaften und Funktionen haben, wie ein Rechteck Eigenschaften wie Länge, Breite, Fläche als Eigenschaften und printArea und berechneArea als seine Funktionen haben kann.

Erstellen einer einfachen Klasse

Eine einfache Klassenimplementierung für ein Rechteck mit drei Eigenschaften, Bereich, Länge und Breite, wird unten gezeigt. Es hat auch eine printArea-Funktion zum Drucken der berechneten Fläche.

-- Meta class
Rectangle = {area = 0, length = 0, breadth = 0}

-- Derived class method new

function Rectangle:new (o,length,breadth)
   o = o or {}
   setmetatable(o, self)
   self.__index = self
   self.length = length or 0
   self.breadth = breadth or 0
   self.area = length*breadth;
   return o
end

-- Derived class method printArea

function Rectangle:printArea ()
   print("The area of Rectangle is ",self.area)
end

Ein Objekt erstellen

Beim Erstellen eines Objekts wird Speicher für die Klasseninstanz zugewiesen. Jedes der Objekte verfügt über einen eigenen Speicher und teilt die gemeinsamen Klassendaten.

r = Rectangle:new(nil,10,20)

Zugriff auf Eigenschaften

Wir können mit dem Punktoperator auf die Eigenschaften in der Klasse zugreifen, wie unten gezeigt -

print(r.length)

Zugriff auf die Mitgliedsfunktion

Sie können auf eine Elementfunktion zugreifen, indem Sie den Doppelpunktoperator mit dem Objekt wie unten gezeigt verwenden.

r:printArea()

Der Speicher wird zugewiesen und die Anfangswerte werden festgelegt. Der Initialisierungsprozess kann mit Konstruktoren in anderen objektorientierten Sprachen verglichen werden. Es ist nichts anderes als eine Funktion, mit der Werte wie oben gezeigt eingestellt werden können.

Vollständiges Beispiel

Schauen wir uns ein vollständiges Beispiel mit Objektorientierung in Lua an.

-- Meta class
Shape = {area = 0}

-- Base class method new

function Shape:new (o,side)
   o = o or {}
   setmetatable(o, self)
   self.__index = self
   side = side or 0
   self.area = side*side;
   return o
end

-- Base class method printArea

function Shape:printArea ()
   print("The area is ",self.area)
end

-- Creating an object
myshape = Shape:new(nil,10)

myshape:printArea()

Wenn Sie das obige Programm ausführen, erhalten Sie die folgende Ausgabe.

The area is 	100

Vererbung in Lua

Bei der Vererbung werden einfache Basisobjekte wie die Form auf Rechtecke, Quadrate usw. erweitert. In der realen Welt wird es häufig verwendet, um die grundlegenden Eigenschaften und Funktionen zu teilen und zu erweitern.

Lassen Sie uns eine einfache Klassenerweiterung sehen. Wir haben eine Klasse wie unten gezeigt.

-- Meta class
Shape = {area = 0}

-- Base class method new

function Shape:new (o,side)
   o = o or {}
   setmetatable(o, self)
   self.__index = self
   side = side or 0
   self.area = side*side;
   return o
end

-- Base class method printArea

function Shape:printArea ()
   print("The area is ",self.area)
end

Wir können die Form wie unten gezeigt auf eine quadratische Klasse erweitern.

Square = Shape:new()

-- Derived class method new

function Square:new (o,side)
   o = o or Shape:new(o,side)
   setmetatable(o, self)
   self.__index = self
   return o
end

Übergeordnete Basisfunktionen

Wir können die Basisklassenfunktionen überschreiben, dh anstatt die Funktion in der Basisklasse zu verwenden, kann die abgeleitete Klasse eine eigene Implementierung haben, wie unten gezeigt -

-- Derived class method printArea

function Square:printArea ()
   print("The area of square is ",self.area)
end

Vererbung vollständiges Beispiel

Wir können die einfache Klassenimplementierung in Lua wie oben gezeigt mit Hilfe einer anderen neuen Methode mit Hilfe von Metatables erweitern. Alle Mitgliedsvariablen und Funktionen der Basisklasse bleiben in der abgeleiteten Klasse erhalten.

-- Meta class
Shape = {area = 0}

-- Base class method new

function Shape:new (o,side)
   o = o or {}
   setmetatable(o, self)
   self.__index = self
   side = side or 0
   self.area = side*side;
   return o
end

-- Base class method printArea

function Shape:printArea ()
   print("The area is ",self.area)
end

-- Creating an object
myshape = Shape:new(nil,10)
myshape:printArea()

Square = Shape:new()

-- Derived class method new

function Square:new (o,side)
   o = o or Shape:new(o,side)
   setmetatable(o, self)
   self.__index = self
   return o
end

-- Derived class method printArea

function Square:printArea ()
   print("The area of square is ",self.area)
end

-- Creating an object
mysquare = Square:new(nil,10)
mysquare:printArea()

Rectangle = Shape:new()

-- Derived class method new

function Rectangle:new (o,length,breadth)
   o = o or Shape:new(o)
   setmetatable(o, self)
   self.__index = self
   self.area = length * breadth
   return o
end

-- Derived class method printArea

function Rectangle:printArea ()
    print("The area of Rectangle is ",self.area)
end

-- Creating an object

myrectangle = Rectangle:new(nil,10,20)
myrectangle:printArea()

Wenn wir das obige Programm ausführen, erhalten wir die folgende Ausgabe:

The area is 	100
The area of square is 	100
The area of Rectangle is 	200

Im obigen Beispiel haben wir zwei abgeleitete Klassen erstellt - Rechteck und Quadrat aus der Basisklasse Quadrat. Es ist möglich, die Funktionen der Basisklasse in der abgeleiteten Klasse zu überschreiben. In diesem Beispiel überschreibt die abgeleitete Klasse die Funktion printArea.

Lua ist eine hochflexible Sprache und wird häufig auf mehreren Plattformen einschließlich Webanwendungen verwendet. Die Kepler-Community, die 2004 gegründet wurde, um Open-Source-Webkomponenten in Lua bereitzustellen.

Obwohl andere Web-Frameworks mit Lua entwickelt wurden, konzentrieren wir uns hauptsächlich auf die Komponenten, die von der Kepler-Community bereitgestellt werden.

Anwendungen und Frameworks

• Orbit ist ein MVC-Webframework für Lua, das auf WSAPI basiert.

• WSAPI ist die API, die den Webhostserver von Lua-Webanwendungen abstrahiert und die Basis für viele Projekte ist.

• Xavante ist ein Lua-Webserver, der eine WSAPI-Schnittstelle bietet.

• Sputnik ist ein Wiki / CMS, das über WSAPI im Kepler-Projekt entwickelt wurde und für Humor und Unterhaltung verwendet wird.

• CGILuabietet die Erstellung von LuaPages- und LuaScripts-Webseiten an, basierend auf WSAPI, aber nicht mehr unterstützt. Verwenden Sie stattdessen Orbit, Sputnik oder WSAPI.

In diesem Tutorial werden wir versuchen, Ihnen zu vermitteln, was Lua kann, und um mehr über seine Installation und Verwendung zu erfahren, lesen Sie bitte die Website

Orbit

Orbit ist ein MVC-Webframework für Lua. Das CGILua-Modell der "Skripte" wird vollständig zugunsten von Anwendungen aufgegeben, bei denen jede Orbit-Anwendung in eine einzelne Datei passen kann. Sie können sie jedoch bei Bedarf in mehrere Dateien aufteilen.

Alle Orbit-Anwendungen folgen dem WSAPI-Protokoll und arbeiten derzeit mit Xavante, CGI und Fastcgi. Es enthält einen Launcher, mit dem eine Xavante-Instanz für die Entwicklung einfach gestartet werden kann.

Der einfachste Weg, Orbit zu installieren, ist die Verwendung von LuaRocks. Luarocks Install Orbit ist der Befehl zur Installation. Dazu müssen Sie zuerst LuaRocks installieren .

Wenn Sie nicht alle Abhängigkeiten installiert haben, müssen Sie die folgenden Schritte ausführen, um Orbit in einer Unix / Linux-Umgebung einzurichten.

Apache installieren

Stellen Sie eine Verbindung zu Ihrem Server her. Installieren Sie Apache2, seine Support-Module und aktivieren Sie die erforderlichen Apache2-Module mit -

$ sudo apt-get install apache2 libapache2-mod-fcgid libfcgi-dev build-essential $ sudo a2enmod rewrite
$ sudo a2enmod fcgid $ sudo /etc/init.d/apache2 force-reload

Installieren Sie LuaRocks

$ sudo apt-get install luarocks

Installieren Sie WSAPI, FCGI, Orbit und Xavante

$ sudo luarocks install orbit
$ sudo luarocks install wsapi-xavante $ sudo luarocks install wsapi-fcgi

Apache2 einrichten

$ sudo raj /etc/apache2/sites-available/default

Fügen Sie diesen folgenden Abschnitt unter dem Abschnitt <Directory / var / www /> der Konfigurationsdatei hinzu. Wenn dieser Abschnitt "AllowOverride None" enthält, müssen Sie "None" in "All" ändern, damit die .htaccess-Datei die Konfiguration lokal überschreiben kann.

<IfModule mod_fcgid.c>

   AddHandler fcgid-script .lua
   AddHandler fcgid-script .ws
   AddHandler fcgid-script .op
	
   FCGIWrapper "/usr/local/bin/wsapi.fcgi" .ws
   FCGIWrapper "/usr/local/bin/wsapi.fcgi" .lua
   FCGIWrapper "/usr/local/bin/op.fcgi" .op
	
   #FCGIServer "/usr/local/bin/wsapi.fcgi" -idle-timeout 60 -processes 1
   #IdleTimeout 60
   #ProcessLifeTime 60
	
</IfModule>

Starten Sie den Server neu, um sicherzustellen, dass die vorgenommenen Änderungen wirksam werden.

Um Ihre Anwendung zu aktivieren, müssen Sie einer .htaccess-Datei im Stammverzeichnis Ihrer Orbit-Anwendung + ExecCGI hinzufügen - in diesem Fall / var / www.

Options +ExecCGI
DirectoryIndex index.ws

Einfaches Beispiel - Umlaufbahn

#!/usr/bin/env index.lua

-- index.lua
require"orbit"

-- declaration
module("myorbit", package.seeall, orbit.new)

-- handler

function index(web)
   return my_home_page()
end

-- dispatch
myorbit:dispatch_get(index, "/", "/index")

-- Sample page

function my_home_page()

   return [[
      <head></head>
      <html>
         <h2>First Page</h2>
      </html>
   ]]
	
end

Jetzt sollten Sie Ihren Webbrowser starten können. Gehen Sie zu http: // localhost: 8080 / und Sie sollten die folgende Ausgabe sehen -

First Page

Orbit bietet eine weitere Option, dh Lua-Code kann HTML generieren.

#!/usr/bin/env index.lua

-- index.lua
require"orbit"

function generate()
   return html {
      head{title "HTML Example"},
		
      body{
         h2{"Here we go again!"}
      }
   }
end

orbit.htmlify(generate)

print(generate())

Formulare erstellen

Ein einfaches Formularbeispiel ist unten dargestellt -

#!/usr/bin/env index.lua
require"orbit"

function wrap (inner)
   return html{ head(), body(inner) }
end

function test ()
   return wrap(form (H'table' {
      tr{td"First name",td( input{type = 'text', name='first'})},
      tr{td"Second name",td(input{type = 'text', name='second'})},
      tr{ td(input{type = 'submit', value = 'Submit!'}),
         td(input{type = 'submit',value = 'Cancel'})
      },
   }))
end

orbit.htmlify(wrap,test)

print(test())

WSAPI

Wie bereits erwähnt, fungiert WSAPI als Basis für viele Projekte und enthält mehrere eingebettete Funktionen. Sie können WSAPI verwenden und die folgenden Plattformen unterstützen:

• Windows
• UNIX-basierte Systeme

Die von WSAPI unterstützten Server und Schnittstellen umfassen:

• CGI
• FastCGI
• Xavante

WSAPI bietet eine Reihe von Bibliotheken, die uns die Webprogrammierung mit Lua erleichtern. Einige der unterstützten Funktionen in Lua umfassen:

• Anfrage bearbeiten
• Ausgabepufferung
• Authentication
• Datei-Uploads
• Isolation anfordern
• Multiplexing

Ein einfaches Beispiel für WSAPI ist unten dargestellt -

#!/usr/bin/env wsapi.cgi

module(..., package.seeall)
function run(wsapi_env)
   local headers = { ["Content-type"] = "text/html" }
   
   local function hello_text()
      coroutine.yield("<html><body>")
      coroutine.yield("<p&gtHello Wsapi!</p>")
      coroutine.yield("<p&gtPATH_INFO: " .. wsapi_env.PATH_INFO .. "</p>")
      coroutine.yield("<p&gtSCRIPT_NAME: " .. wsapi_env.SCRIPT_NAME .. "</p>")
      coroutine.yield("</body></html>")
   end

   return 200, headers, coroutine.wrap(hello_text)
end

Sie können im obigen Code sehen, dass eine einfache HTML-Seite gebildet und zurückgegeben wird. Sie können die Verwendung von Coroutinen sehen, die es ermöglichen, Anweisung für Anweisung an die aufrufende Funktion zurückzugeben. Schließlich werden der HTML-Statuscode (200), die Header und die HTML-Seite zurückgegeben.

Xavante

Xavante ist ein Lua HTTP 1.1-Webserver, der eine modulare Architektur verwendet, die auf URI-zugeordneten Handlern basiert. Xavante bietet derzeit an,

• Dateihandler
• Handler umleiten
• WSAPI-Handler

Der Dateihandler wird für allgemeine Dateien verwendet. Der Redirect-Handler aktiviert die URI-Neuzuordnung und den WSAPI-Handler für die Handhabung mit WSAPI-Anwendungen.

Ein einfaches Beispiel ist unten gezeigt.

require "xavante.filehandler"
require "xavante.cgiluahandler"
require "xavante.redirecthandler"

-- Define here where Xavante HTTP documents scripts are located
local webDir = XAVANTE_WEB

local simplerules = {

   { -- URI remapping example
      match = "^[^%./]*/$",
      with = xavante.redirecthandler,
      params = {"index.lp"}
   }, 

   { -- cgiluahandler example
      match = {"%.lp$", "%.lp/.*$", "%.lua$", "%.lua/.*$" },
      with = xavante.cgiluahandler.makeHandler (webDir)
   },
    
   { -- filehandler example
      match = ".",
      with = xavante.filehandler,
      params = {baseDir = webDir}
   },
} 

xavante.HTTP{
   server = {host = "*", port = 8080},
    
   defaultHost = {
      rules = simplerules
   },
}

Um virtuelle Hosts mit Xavante zu verwenden, wird der Aufruf von xavante.HTTP wie folgt geändert:

xavante.HTTP{
   server = {host = "*", port = 8080},
    
   defaultHost = {},
    
   virtualhosts = {
      ["www.sitename.com"] = simplerules
   }
}

Lua Webkomponenten

• Copas, ein Dispatcher basierend auf Coroutinen, die von TCP / IP-Servern verwendet werden können.

• Cosmo, eine "sichere Vorlagen" -Engine, die Ihre Anwendung vor beliebigem Code in den Vorlagen schützt.

• Coxpcall kapselt Lua native pcall und xpcall mit Coroutine-kompatiblen.

• LuaFileSystem, eine tragbare Möglichkeit, auf die zugrunde liegende Verzeichnisstruktur und die Dateiattribute zuzugreifen.

• Rings, eine Bibliothek, die eine Möglichkeit bietet, neue Lua-Zustände innerhalb von Lua zu erstellen.

Schlussbemerkung

Es gibt so viele Lua-basierte Web-Frameworks und -Komponenten, die je nach Bedarf ausgewählt werden können. Es sind andere Web-Frameworks verfügbar, die Folgendes umfassen:

• Moonstalkermöglicht die effiziente Entwicklung und das Hosting dynamisch generierter webbasierter Projekte, die mit der Sprache Lua erstellt wurden; von einfachen Seiten bis zu komplexen Anwendungen.

• Lapis, ein Framework zum Erstellen von Webanwendungen mit MoonScript (oder Lua), das in einer angepassten Version von Nginx namens OpenResty ausgeführt wird.

• Lua Server Pages, ein Plug-In für die Lua-Scripting-Engine, das jeden anderen Ansatz für die Entwicklung eingebetteter Websites zunichte macht, bietet eine dramatische Abkürzung zu herkömmlichen C-Serverseiten.

Diese Webframeworks können Ihre Webanwendungen nutzen und Sie bei leistungsstarken Vorgängen unterstützen.

Für einfache Datenoperationen verwenden wir möglicherweise Dateien, aber manchmal sind diese Dateivorgänge möglicherweise nicht effizient, skalierbar und leistungsstark. Zu diesem Zweck wechseln wir häufig zur Verwendung von Datenbanken. LuaSQL ist eine einfache Schnittstelle von Lua zu einer Reihe von Datenbankverwaltungssystemen. LuaSQL ist die Bibliothek, die verschiedene Arten von SQL unterstützt. Dazu gehören:

• SQLite
• Mysql
• ODBC

In diesem Tutorial werden wir uns mit der Datenbankverarbeitung von MySQL und SQLite in Lua befassen. Dies verwendet eine generische Schnittstelle für beide und sollte möglich sein, diese Implementierung auch auf andere Datenbanktypen zu portieren. Lassen Sie uns zunächst sehen, wie Sie die Operationen in MySQL ausführen können.

MySQL db Setup

Damit die folgenden Beispiele wie erwartet funktionieren, benötigen wir das anfängliche Datenbank-Setup. Die Annahmen sind unten aufgeführt.

• Sie haben MySQL mit dem Standardbenutzer als Root und dem Kennwort '123456' installiert und eingerichtet.

• Sie haben einen Datenbanktest erstellt.

• Sie haben das MySQL-Tutorial durchgearbeitet, um die MySQL-Grundlagen zu verstehen .

MySQL importieren

Wir können eine einfache verwenden require Anweisung zum Importieren der SQLite-Bibliothek unter der Annahme, dass Ihre Lua-Implementierung korrekt durchgeführt wurde.

mysql = require "luasql.mysql"

Die Variable mysql ermöglicht den Zugriff auf die Funktionen unter Bezugnahme auf die Haupttabelle mysql.

Verbindung einrichten

Wir können die Verbindung einrichten, indem wir eine MySQL-Umgebung initiieren und dann eine Verbindung für die Umgebung herstellen. Es ist unten gezeigt.

local env  = mysql.mysql()
local conn = env:connect('test','root','123456')

Die obige Verbindung stellt eine Verbindung zu einer vorhandenen MySQL-Datei her und stellt die Verbindung mit der neu erstellten Datei her.

Funktion ausführen

Mit der Verbindung steht eine einfache Ausführungsfunktion zur Verfügung, mit der wir alle Datenbankoperationen wie Erstellen, Einfügen, Löschen, Aktualisieren usw. ausführen können. Die Syntax wird unten gezeigt -

conn:execute([[ 'MySQLSTATEMENT' ]])

In der obigen Syntax müssen wir sicherstellen, dass conn offen ist und eine MySQL-Verbindung besteht, und die 'MySQLSTATEMENT' durch die richtige Anweisung ersetzen.

Tabellenbeispiel erstellen

Ein einfaches Beispiel zum Erstellen einer Tabelle ist unten dargestellt. Es wird eine Tabelle mit zwei Parametern ID vom Typ Ganzzahl und Name vom Typ Varchar erstellt.

mysql = require "luasql.mysql"

local env  = mysql.mysql()
local conn = env:connect('test','root','123456')

print(env,conn)

status,errorString = conn:execute([[CREATE TABLE sample2 (id INTEGER, name TEXT);]])
print(status,errorString )

Wenn Sie das obige Programm ausführen, wird eine Tabelle mit dem Namen sample mit zwei Spalten erstellt, nämlich id und name.

MySQL environment (004BB178)	MySQL connection (004BE3C8)
0	nil

Im Fehlerfall wird anstelle von Null eine Fehleranweisung zurückgegeben. Eine einfache Fehleranweisung ist unten dargestellt.

LuaSQL: Error executing query. MySQL: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near '"id INTEGER, name TEXT)' at line 1

Beispiel für eine Anweisung einfügen

Eine insert-Anweisung für MySQL ist unten dargestellt.

conn:execute([[INSERT INTO sample values('11','Raj')]])

Beispiel für eine Update-Anweisung

Eine Update-Anweisung für MySQL ist unten dargestellt.

conn:execute([[UPDATE sample3 SET name='John' where id ='12']])

Beispiel für eine Anweisung löschen

Eine Löschanweisung für MySQL ist unten dargestellt.

conn:execute([[DELETE from sample3 where id ='12']])

Wählen Sie Anweisungsbeispiel

In Bezug auf die select-Anweisung müssen wir jede der Zeilen durchlaufen und die erforderlichen Daten extrahieren. Eine einfache select-Anweisung ist unten dargestellt.

cursor,errorString = conn:execute([[select * from sample]])
row = cursor:fetch ({}, "a")

while row do
   print(string.format("Id: %s, Name: %s", row.id, row.name))
   -- reusing the table of results
   row = cursor:fetch (row, "a")
end

Im obigen Code ist conn eine offene MySQL-Verbindung. Mit Hilfe des von der execute-Anweisung zurückgegebenen Cursors können Sie die Tabellenantwort durchlaufen und die erforderlichen Auswahldaten abrufen.

Ein vollständiges Beispiel

Ein vollständiges Beispiel mit allen obigen Aussagen ist unten angegeben.

mysql = require "luasql.mysql"

local env  = mysql.mysql()
local conn = env:connect('test','root','123456')
print(env,conn)

status,errorString = conn:execute([[CREATE TABLE sample3 (id INTEGER, name TEXT)]])
print(status,errorString )

status,errorString = conn:execute([[INSERT INTO sample3 values('12','Raj')]])
print(status,errorString )

cursor,errorString = conn:execute([[select * from sample3]])
print(cursor,errorString)

row = cursor:fetch ({}, "a")

while row do
   print(string.format("Id: %s, Name: %s", row.id, row.name))
   row = cursor:fetch (row, "a")
end

-- close everything
cursor:close()
conn:close()
env:close()

Wenn Sie das obige Programm ausführen, erhalten Sie die folgende Ausgabe.

MySQL environment (0037B178)	MySQL connection (0037EBA8)
0	nil
1	nil
MySQL cursor (003778A8)	nil
Id: 12, Name: Raj

Transaktionen durchführen

Transaktionen sind ein Mechanismus, der die Datenkonsistenz gewährleistet. Transaktionen sollten die folgenden vier Eigenschaften haben:

• Atomicity - Entweder wird eine Transaktion abgeschlossen oder es passiert überhaupt nichts.

• Consistency - Eine Transaktion muss in einem konsistenten Zustand beginnen und das System in einem konsistenten Zustand belassen.

• Isolation - Zwischenergebnisse einer Transaktion sind außerhalb der aktuellen Transaktion nicht sichtbar.

• Durability - Sobald eine Transaktion festgeschrieben wurde, bleiben die Auswirkungen auch nach einem Systemausfall bestehen.

Die Transaktion beginnt mit START TRANSACTION. und endet mit einer Commit- oder Rollback-Anweisung.

Transaktion starten

Um eine Transaktion zu initiieren, müssen wir die folgende Anweisung in Lua ausführen, vorausgesetzt, conn ist eine offene MySQL-Verbindung.

conn:execute([[START TRANSACTION;]])

Rollback-Transaktion

Wir müssen die folgende Anweisung ausführen, um Änderungen rückgängig zu machen, die nach der Ausführung der Starttransaktion vorgenommen wurden.

conn:execute([[ROLLBACK;]])

Transaktion festschreiben

Wir müssen die folgende Anweisung ausführen, um Änderungen festzuschreiben, die nach der Ausführung der Starttransaktion vorgenommen wurden.

conn:execute([[COMMIT;]])

Wir haben im obigen Abschnitt von MySQL gewusst und im folgenden Abschnitt werden grundlegende SQL-Operationen erläutert. Denken Sie daran, dass Transaktionen zwar für SQLite3 nicht noch einmal erklärt wurden, die gleichen Anweisungen jedoch auch für SQLite3 funktionieren sollten.

SQLite importieren

Wir können eine einfache require-Anweisung verwenden, um die SQLite-Bibliothek zu importieren, vorausgesetzt, Ihre Lua-Implementierung wurde korrekt durchgeführt. Während der Installation ein Ordner libsql, der die datenbankbezogenen Dateien enthält.

sqlite3 = require "luasql.sqlite3"

Die Variable sqlite3 ermöglicht den Zugriff auf die Funktionen unter Bezugnahme auf die Haupttabelle sqlite3.

Verbindung einrichten

Wir können die Verbindung einrichten, indem wir eine SQLite-Umgebung initiieren und dann eine Verbindung für die Umgebung herstellen. Es ist unten gezeigt.

local env  = sqlite3.sqlite3()
local conn = env:connect('mydb.sqlite')

Die obige Verbindung stellt eine Verbindung zu einer vorhandenen SQLite-Datei her oder erstellt eine neue SQLite-Datei und stellt die Verbindung mit der neu erstellten Datei her.

Funktion ausführen

Mit der Verbindung steht eine einfache Ausführungsfunktion zur Verfügung, mit der wir alle Datenbankoperationen wie Erstellen, Einfügen, Löschen, Aktualisieren usw. ausführen können. Die Syntax wird unten gezeigt -

conn:execute([[ 'SQLite3STATEMENT' ]])

In der obigen Syntax müssen wir sicherstellen, dass conn offen ist und eine SQLite3-Verbindung besteht, und die 'SQLite3STATEMENT' durch die richtige Anweisung ersetzen.

Tabellenbeispiel erstellen

Ein einfaches Beispiel zum Erstellen einer Tabelle ist unten dargestellt. Es wird eine Tabelle mit zwei Parametern ID vom Typ Ganzzahl und Name vom Typ Varchar erstellt.

sqlite3 = require "luasql.sqlite3"

local env  = sqlite3.sqlite3()
local conn = env:connect('mydb.sqlite')
print(env,conn)

status,errorString = conn:execute([[CREATE TABLE sample ('id' INTEGER, 'name' TEXT)]])
print(status,errorString )

Wenn Sie das obige Programm ausführen, wird eine Tabelle mit dem Namen sample mit zwei Spalten erstellt, nämlich id und name.

SQLite3 environment (003EC918)	SQLite3 connection (00421F08)
0	nil

Im Falle eines Fehlers erhalten Sie eine Fehleranweisung anstelle von Null. Eine einfache Fehleranweisung ist unten dargestellt.

LuaSQL: unrecognized token: ""'id' INTEGER, 'name' TEXT)"

Beispiel für eine Anweisung einfügen

Eine Einfügeanweisung für SQLite wird unten gezeigt.

conn:execute([[INSERT INTO sample values('11','Raj')]])

Wählen Sie Anweisungsbeispiel

In Bezug auf die select-Anweisung müssen wir jede der Zeilen durchlaufen und die erforderlichen Daten extrahieren. Eine einfache select-Anweisung ist unten dargestellt.

cursor,errorString = conn:execute([[select * from sample]])
row = cursor:fetch ({}, "a")

while row do
   print(string.format("Id: %s, Name: %s", row.id, row.name))
   -- reusing the table of results
   row = cursor:fetch (row, "a")
end

Im obigen Code ist conn eine offene sqlite3-Verbindung. Mit Hilfe des von der execute-Anweisung zurückgegebenen Cursors können Sie die Tabellenantwort durchlaufen und die erforderlichen Auswahldaten abrufen.

Ein vollständiges Beispiel

Ein vollständiges Beispiel mit allen obigen Aussagen ist unten angegeben.

sqlite3 = require "luasql.sqlite3"

local env  = sqlite3.sqlite3()
local conn = env:connect('mydb.sqlite')
print(env,conn)

status,errorString = conn:execute([[CREATE TABLE sample ('id' INTEGER, 'name' TEXT)]])
print(status,errorString )

status,errorString = conn:execute([[INSERT INTO sample values('1','Raj')]])
print(status,errorString )

cursor,errorString = conn:execute([[select * from sample]])
print(cursor,errorString)

row = cursor:fetch ({}, "a")

while row do
   print(string.format("Id: %s, Name: %s", row.id, row.name))
   row = cursor:fetch (row, "a")
end

-- close everything
cursor:close()
conn:close()
env:close()

Wenn Sie das obige Programm ausführen, erhalten Sie die folgende Ausgabe.

SQLite3 environment (005EC918)	SQLite3 connection (005E77B0)
0	nil
1	nil
SQLite3 cursor (005E9200)	nil
Id: 1, Name: Raj

Mit Hilfe dieser libsql-Bibliothek können wir alle verfügbaren Abfragen ausführen. Hören Sie also bitte nicht mit diesen Beispielen auf. Experimentieren Sie mit verschiedenen Abfrageanweisungen, die in MySQL, SQLite3 und anderen unterstützten Datenbanken in Lua verfügbar sind.

Lua wird aufgrund seiner einfachen Sprachstruktur und Syntax in vielen Spiel-Engines verwendet. Die Garbage Collection-Funktion ist häufig sehr nützlich in Spielen, die aufgrund der verwendeten umfangreichen Grafiken viel Speicherplatz beanspruchen. Einige Spiel-Engines, die Lua verwenden, enthalten -

• Corona SDK
• Gideros Mobile
• ShiVa3D
• Moai SDK
• LOVE
• CryEngine

Jede dieser Spiel-Engines basiert auf Lua und in jeder dieser Engines ist eine Vielzahl von APIs verfügbar. Wir werden uns kurz mit den Fähigkeiten der einzelnen befassen.

Corona SDK

Das Corona SDK ist eine plattformübergreifende mobile Spiele-Engine, die iPhone-, iPad- und Android-Plattformen unterstützt. Es gibt eine kostenlose Version des Corona SDK, die für kleine Spiele mit eingeschränkten Funktionen verwendet werden kann. Sie können bei Bedarf auf andere Versionen aktualisieren.

Das Corona SDK bietet eine Reihe von Funktionen, darunter:

• APIs für Physik und Kollisionsbehandlung
• Web- und Netzwerk-APIs
• Game Network API
• Anzeigen-API
• Analytics-API
• Datenbank- und Dateisystem-APIs
• Krypto- und Mathematik-APIs
• Audio- und Medien-APIs

Es ist einfacher und schneller, eine Anwendung mit den oben genannten APIs zu entwickeln, als die nativen APIs für iOS und Android separat zu verwenden.

Gideros Mobile

Gideros bietet das plattformübergreifende SDK zum Erstellen von Spielen für iOS und Android. Es ist kostenlos mit einem mit Gideros gemachten Spritzer zu verwenden. Einige der bemerkenswerten Vorteile von Gideoros sind:

• Development IDE - Es bietet eine eigene IDE, die die Entwicklung von Gideros-Apps erleichtert.

• Instant testing- Während der Entwicklung Ihres Spiels kann es in nur 1 Sekunde über WLAN auf einem realen Gerät getestet werden. Sie müssen Ihre Zeit nicht mit einem Export- oder Bereitstellungsprozess verschwenden.

• Plugins- Sie können den Kern einfach mit Plugins erweitern. Importieren Sie Ihren vorhandenen Code (C, C ++, Java oder Obj-C), binden Sie ihn an Lua und interpretieren Sie ihn direkt. Dutzende von Open-Source-Plugins sind bereits entwickelt und einsatzbereit.

• Clean OOP approach - Gideros bietet ein eigenes Klassensystem mit allen grundlegenden OOP-Standards, mit denen Sie sauberen und wiederverwendbaren Code für jedes Ihrer zukünftigen Spiele schreiben können.

• Native speed - Entwickelt auf C / C ++ und OpenGL, läuft Ihr Spiel mit nativer Geschwindigkeit und nutzt die Leistung der darunter liegenden CPUs und GPUs voll aus.

ShiVa3D

ShiVa3D ist eine der 3D-Spiele-Engines, die einen grafischen Editor zum Erstellen von Anwendungen und Videospielen für das Web, Konsolen und mobile Geräte bereitstellt. Es unterstützt mehrere Plattformen, darunter Windows, Mac, Linux, iOS, Android, BlackBerry, Palm OS, Wii und WebOS.

Einige der Hauptmerkmale umfassen

• Standard Plugins
• Mesh Modification API
• IDE
• Eingebauter Terrain-, Ocean- und Animationseditor
• Unterstützung für ODE-Physik-Engines
• Volle Lightmap-Steuerung
• Live-Vorschau für Materialien, Partikel, Trails und HUDs
• Unterstützung für das Collada-Austauschformat

Die Web-Edition von Shiva3d ist völlig kostenlos und andere Editionen, die Sie abonniert haben.

Moai SDK

Moai SDK ist eine plattformübergreifende mobile Spiel-Engine, die iPhone-, iPad- und Android-Plattformen unterstützt. Die Moai-Plattform bestand ursprünglich aus Moai SDK, einer Open-Source-Game-Engine, und Moai Cloud, einer Cloud-Plattform als Service für das Hosting und die Bereitstellung von Game-Services. Jetzt wird die Moai Cloud heruntergefahren und nur die Spiel-Engine ist verfügbar.

Das Moai SDK läuft auf mehreren Plattformen, einschließlich iOS, Android, Chrome, Windows, Mac und Linux.

LIEBE

LIEBE ist ein Framework, mit dem Sie 2D-Spiele erstellen können. Es ist kostenlos und Open Source. Es unterstützt Windows-, Mac OS X- und Linux-Plattformen.

Es bietet mehrere Funktionen, darunter:

• Audio-API
• Dateisystem-API
• Tastatur- und Joystick-APIs
• Math API
• Fenster- und Maus-APIs
• Physik-API
• System- und Timer-APIs

CryEngine

CryEngine ist eine Spiel-Engine, die vom deutschen Spieleentwickler Crytek entwickelt wurde. Es hat sich von Generation 1 zu Generation 4 entwickelt und ist eine fortschrittliche Entwicklungslösung. Es unterstützt PC-, Xbox 360-, PlayStation3- und WiiU-Spiele.

Es bietet mehrere Funktionen, darunter:

• Visuelle Effekte wie natürliches Licht und dynamische weiche Schatten, dynamische globale Echtzeitbeleuchtung, Lichtausbreitungsvolumen, Partikelschattierung, Tessellation usw.

• Charakteranimationssystem und Charakterindividualisierungssystem.

• Parametrische Skelettanimation und einzigartiger dedizierter Gesichtsanimationseditor

• KI-Systeme wie das mehrschichtige Navigationsnetz und das taktische Punktesystem. Bietet auch ein Designer-freundliches AI-Bearbeitungssystem.

• In Game Mixing & Profiling, datengesteuertem Soundsystem, dynamischen Sounds und interaktiver Musik und so weiter.

• Physikmerkmale wie prozedurale Verformung und fortgeschrittene Seilphysik.

Eine abschließende Anmerkung

Jedes dieser Game SDKs / Frameworks hat seine eigenen Vor- und Nachteile. Eine richtige Wahl zwischen ihnen erleichtert Ihre Aufgabe und Sie können eine bessere Zeit damit haben. Bevor Sie es verwenden, müssen Sie die Anforderungen für Ihr Spiel kennen und dann analysieren, welche alle Ihre Anforderungen erfüllen, und diese dann verwenden.

Lua-Standardbibliotheken bieten eine Vielzahl von Funktionen, die direkt mit der C-API implementiert und in die Programmiersprache Lua integriert sind. Diese Bibliotheken bieten Dienste innerhalb der Programmiersprache Lua sowie externe Dienste wie Datei- und Datenbankoperationen.

Diese in der offiziellen C-API integrierten Standardbibliotheken werden als separate C-Module bereitgestellt. Es enthält die folgenden -

• Basisbibliothek, die die Coroutine-Unterbibliothek enthält
• Modulbibliothek
• String-Manipulation
• Tabellenmanipulation
• Mathematikbibliothek
• Dateieingabe und -ausgabe
• Betriebssystemeinrichtungen
• Debug-Funktionen

Basisbibliothek

Wir haben die Basisbibliothek im gesamten Tutorial unter verschiedenen Themen verwendet. Die folgende Tabelle enthält Links zu verwandten Seiten und listet die Funktionen auf, die in verschiedenen Teilen dieses Lua-Tutorials behandelt werden.

Sr.Nr.	Bibliothek / Methode & Zweck
1	Error Handling Enthält Fehlerbehandlungsfunktionen wie Assert, Fehler, wie in Lua - Fehlerbehandlung erläutert .
2	Memory Management Enthält die automatischen Speicherverwaltungsfunktionen für die Speicherbereinigung, wie in Lua - Speicherbereinigung erläutert .
3	dofile ([filename]) Es öffnet die Datei und führt den Inhalt der Datei als Block aus. Wenn kein Parameter übergeben wird, führt diese Funktion den Inhalt der Standardeingabe aus. Die Fehler werden an den Anrufer weitergegeben.
4	_G Somit ist die globale Variable, die die globale Umgebung enthält (dh _G._G = _G). Lua selbst verwendet diese Variable nicht.
5	getfenv ([f]) Gibt die aktuell von der Funktion verwendete Umgebung zurück. f kann eine Lua-Funktion oder eine Zahl sein, die die Funktion auf dieser Stapelebene angibt - Ebene 1 ist die Funktion, die getfenv aufruft. Wenn die angegebene Funktion keine Lua-Funktion ist oder wenn f 0 ist, gibt getfenv die globale Umgebung zurück. Der Standardwert für f ist 1.
6	getmetatable (object) Wenn das Objekt keine Metatabelle hat, wird nil zurückgegeben. Andernfalls gibt der zugehörige Wert zurück, wenn die Metatabelle des Objekts ein Feld "__metatable" enthält. Andernfalls wird die Metatabelle des angegebenen Objekts zurückgegeben.
7	ipairs (t) Diese Funktion ruft die Indizes und Werte von Tabellen ab.
8	load (func [, chunkname]) Lädt einen Block mit der Funktion func, um seine Teile zu erhalten. Jeder Aufruf von func muss eine Zeichenfolge zurückgeben, die mit früheren Ergebnissen verknüpft ist.
9	loadfile ([filename])) Ähnlich wie beim Laden, bezieht den Block jedoch aus dem Dateinamen der Datei oder aus der Standardeingabe, wenn kein Dateiname angegeben ist.
10	loadstring (string [, chunkname]) Ähnlich wie beim Laden, erhält jedoch den Block aus der angegebenen Zeichenfolge.
11	next (table [, index]) Ermöglicht einem Programm, alle Felder einer Tabelle zu durchlaufen. Das erste Argument ist eine Tabelle und das zweite Argument ist ein Index in dieser Tabelle. next gibt den nächsten Index der Tabelle und den zugehörigen Wert zurück.
12	pairs (t) Hält die laufende Coroutine an. Der an diese Methode übergebene Parameter dient als zusätzliche Rückgabewerte für die Wiederaufnahmefunktion.
13	print (...) Hält die laufende Coroutine an. Der an diese Methode übergebene Parameter dient als zusätzliche Rückgabewerte für die Wiederaufnahmefunktion.
14	rawequal (v1, v2) Überprüft, ob v1 gleich v2 ist, ohne eine Metamethode aufzurufen. Gibt einen Booleschen Wert zurück.
15	rawget (table, index) Ruft den tatsächlichen Wert von table [index] ab, ohne eine Metamethode aufzurufen. Tabelle muss eine Tabelle sein; Index kann ein beliebiger Wert sein.
16	rawset (table, index, value) Setzt den tatsächlichen Wert von Tabelle [Index] auf Wert, ohne eine Metamethode aufzurufen. Die Tabelle muss eine Tabelle sein, einen beliebigen Wert von nil indizieren und einen beliebigen Lua-Wert bewerten. Diese Funktion gibt die Tabelle zurück.
17	select (index, ...) Wenn index eine Zahl ist, werden alle Argumente nach dem Argumentnummernindex zurückgegeben. Andernfalls muss der Index die Zeichenfolge "#" sein, und select gibt die Gesamtzahl der empfangenen zusätzlichen Argumente zurück.
18	setfenv (f, table) Legt die Umgebung fest, die von der angegebenen Funktion verwendet werden soll. f kann eine Lua-Funktion oder eine Zahl sein, die die Funktion auf dieser Stapelebene angibt - Ebene 1 ist die Funktion, die setfenv aufruft. setfenv gibt die angegebene Funktion zurück. Als Sonderfall ändert setfenv die Umgebung des laufenden Threads, wenn f 0 ist. In diesem Fall gibt setfenv keine Werte zurück.
19	setmetatable (table, metatable) Legt die Metatabelle für die angegebene Tabelle fest. (Sie können die Metatabelle anderer Typen nicht von Lua aus ändern, sondern nur von C.) Wenn die Metatabelle Null ist, wird die Metatabelle der angegebenen Tabelle entfernt. Wenn die ursprüngliche Metatabelle ein Feld "__metatierbar" enthält, wird ein Fehler ausgelöst. Diese Funktion gibt die Tabelle zurück.
20	tonumber (e [, base]) Versucht, sein Argument in eine Zahl umzuwandeln. Wenn das Argument bereits eine Zahl oder eine Zeichenfolge ist, die in eine Zahl konvertierbar ist, gibt tonumber diese Zahl zurück. Andernfalls wird null zurückgegeben.
21	tostring (e) Empfängt ein Argument eines beliebigen Typs und konvertiert es in eine Zeichenfolge in einem angemessenen Format. Verwenden Sie string.format, um die Konvertierung von Zahlen vollständig zu steuern.
22	type (v) Gibt den Typ des einzigen Arguments zurück, das als Zeichenfolge codiert ist. Die möglichen Ergebnisse dieser Funktion sind "nil" (eine Zeichenfolge, nicht der Wert nil), "number", "string", "boolean", "table", "function", "thread" und "userdata".
23	unpack (list [, i [, j]]) Gibt die Elemente aus der angegebenen Tabelle zurück.
24	_VERSION Eine globale Variable (keine Funktion), die eine Zeichenfolge enthält, die die aktuelle Interpreterversion enthält. Der aktuelle Inhalt dieser Variablen ist "Lua 5.1".
25	Coroutines Enthält die Coroutine-Manipulationsfunktionen, wie in Lua - Coroutines erläutert .

Modulbibliothek

Die Modulbibliothek bietet die Grundfunktionen zum Laden von Modulen in Lua. Es exportiert eine Funktion direkt in die globale Umgebung: erfordern. Alles andere wird in ein Tabellenpaket exportiert. Die Details zur Modulbibliothek werden im vorherigen Kapitel Lua - Module Tutorial erläutert .

String-Manipulation

Lua bietet eine Vielzahl von Funktionen zur Manipulation von Zeichenfolgen. Das frühere Lua-Strings- Tutorial behandelt dies ausführlich.

Tabellenmanipulation

Lua ist in fast allen Bereichen auf Tabellen angewiesen. Das frühere Tutorial zu Lua - Tables behandelt dies ausführlich.

Dateieingabe und -ausgabe

Wir benötigen häufig Datenspeicherfunktionen für die Programmierung, die durch Standardbibliotheksfunktionen für Datei-E / A in Lua bereitgestellt werden. Dies wird in einem früheren Lua - File I / O- Tutorial erläutert .

Debug-Funktionen

Lua bietet eine Debug-Bibliothek, die alle primitiven Funktionen zum Erstellen eines eigenen Debuggers bietet. Es wird in einem früheren Lua - Debugging - Tutorial besprochen .

Wir benötigen häufig mathematische Operationen in wissenschaftlichen und technischen Berechnungen und können diese mithilfe der Standard-Lua-Bibliotheksmathematik nutzen. Die Liste der in der Mathematikbibliothek verfügbaren Funktionen ist in der folgenden Tabelle aufgeführt.

Sr.Nr.	Bibliothek / Methode & Zweck
1	math.abs (x) Gibt den absoluten Wert von x zurück.
2	math.acos (x) Gibt den Bogenkosinus von x (im Bogenmaß) zurück.
3	math.asin (x) Gibt den Bogensinus von x (im Bogenmaß) zurück.
4	math.atan (x) Gibt den Bogentangens von x (im Bogenmaß) zurück.
5	math.atan2 (y, x) Gibt den Arcustangens von y / x (im Bogenmaß) zurück, verwendet jedoch die Vorzeichen beider Parameter, um den Quadranten des Ergebnisses zu ermitteln. (Es behandelt auch den Fall, dass x Null ist, korrekt.)
6	math.ceil (x) Gibt die kleinste Ganzzahl zurück, die größer oder gleich x ist.
7	math.cos (x) Gibt den Cosinus von x zurück (angenommen im Bogenmaß).
8	math.cosh (x) Gibt den hyperbolischen Cosinus von x zurück.
9	math.deg (x) Gibt den Winkel x (im Bogenmaß angegeben) in Grad zurück.
10	math.exp (x) Gibt den Wert e Potenz x zurück.
11	math.floor (x) Gibt die größte Ganzzahl zurück, die kleiner oder gleich x ist.
12	math.fmod (x, y) Gibt den Rest der Division von x durch y zurück, die den Quotienten gegen Null rundet.
13	math.frexp (x) Gibt m und e so zurück, dass x = m2e, e eine ganze Zahl ist und der Absolutwert von m im Bereich [0,5, 1) liegt (oder Null, wenn x Null ist).
14	math.huge Der Wert HUGE_VAL, ein Wert, der größer oder gleich einem anderen numerischen Wert ist.
15	math.ldexp (m, e) Gibt m2e zurück (e sollte eine ganze Zahl sein).
16	math.log (x) Gibt den natürlichen Logarithmus von x zurück.
17	math.log10 (x) Gibt den Basis-10-Logarithmus von x zurück.
18	math.max (x, ...) Gibt den Maximalwert unter den Argumenten zurück.
19	math.min (x, ...) Gibt den Mindestwert unter den Argumenten zurück.
20	math.modf (x) Gibt zwei Zahlen zurück, den Integralteil von x und den Bruchteil von x.
21	math.pi Der Wert von pi.
22	math.pow (x, y) Gibt xy zurück. (Sie können diesen Wert auch mit dem Ausdruck x ^ y berechnen.)
23	math.rad (x) Gibt den Winkel x (in Grad) im Bogenmaß zurück.
24	math.random ([m [, n]]) Diese Funktion ist eine Schnittstelle zu der einfachen Pseudozufallsgeneratorfunktion rand, die von ANSI C bereitgestellt wird. Wenn sie ohne Argumente aufgerufen wird, gibt sie eine einheitliche Pseudozufalls-reelle Zahl im Bereich [0,1] zurück. Beim Aufruf mit einer Ganzzahl m gibt math.random eine einheitliche Pseudozufallszahl im Bereich [1, m] zurück. Beim Aufruf mit zwei Ganzzahlen m und n gibt math.random eine einheitliche Pseudozufallszahl im Bereich [m, n] zurück.
25	math.randomseed (x) Setzt x als "Startwert" für den Pseudozufallsgenerator: Gleiche Startwerte erzeugen gleiche Zahlenfolgen.
26	math.sin (x) Gibt den Sinus von x zurück (angenommen im Bogenmaß).
27	math.sinh (x) Gibt den hyperbolischen Sinus von x zurück.
28	math.sqrt (x) Gibt die Quadratwurzel von x zurück. (Sie können diesen Wert auch mit dem Ausdruck x ^ 0.5 berechnen.)
29	math.tan (x) Gibt den Tangens von x zurück (angenommen im Bogenmaß).
30	math.tanh (x) Gibt den hyperbolischen Tangens von x zurück.

Trigonometrische Funktionen

Ein einfaches Beispiel mit trigonometrischer Funktion ist unten dargestellt.

radianVal = math.rad(math.pi / 2)

io.write(radianVal,"\n")

-- Sin value of 90(math.pi / 2) degrees
io.write(string.format("%.1f ", math.sin(radianVal)),"\n")

-- Cos value of 90(math.pi / 2) degrees
io.write(string.format("%.1f ", math.cos(radianVal)),"\n")

-- Tan value of 90(math.pi / 2) degrees
io.write(string.format("%.1f ", math.tan(radianVal)),"\n")

-- Cosh value of 90(math.pi / 2) degrees
io.write(string.format("%.1f ", math.cosh(radianVal)),"\n")

-- Pi Value in degrees
io.write(math.deg(math.pi),"\n")

Wenn wir das obige Programm ausführen, erhalten wir die folgende Ausgabe.

0.027415567780804
0.0 
1.0 
0.0 
1.0 
180

Andere gängige mathematische Funktionen

Ein einfaches Beispiel mit allgemeinen mathematischen Funktionen ist unten dargestellt.

-- Floor
io.write("Floor of 10.5055 is ", math.floor(10.5055),"\n")

-- Ceil
io.write("Ceil of 10.5055 is ", math.ceil(10.5055),"\n")

-- Square root
io.write("Square root of 16 is ",math.sqrt(16),"\n")

-- Power
io.write("10 power 2 is ",math.pow(10,2),"\n")
io.write("100 power 0.5 is ",math.pow(100,0.5),"\n")

-- Absolute
io.write("Absolute value of -10 is ",math.abs(-10),"\n")

--Random
math.randomseed(os.time())
io.write("Random number between 1 and 100 is ",math.random(),"\n")

--Random between 1 to 100
io.write("Random number between 1 and 100 is ",math.random(1,100),"\n")

--Max
io.write("Maximum in the input array is ",math.max(1,100,101,99,999),"\n")

--Min
io.write("Minimum in the input array is ",math.min(1,100,101,99,999),"\n")

Wenn wir das obige Programm ausführen, erhalten wir die folgende Ausgabe.

Floor of 10.5055 is 10
Ceil of 10.5055 is 11
Square root of 16 is 4
10 power 2 is 100
100 power 0.5 is 10
Absolute value of -10 is 10
Random number between 1 and 100 is 0.22876674703207
Random number between 1 and 100 is 7
Maximum in the input array is 999
Minimum in the input array is 1

Die obigen Beispiele sind nur einige der gängigen Beispiele. Wir können die Mathematikbibliothek je nach Bedarf verwenden. Versuchen Sie daher, alle Funktionen zu verwenden, um sich besser vertraut zu machen.

In jeder Anwendung ist es häufig erforderlich, auf Funktionen auf Betriebssystemebene zuzugreifen, und es wird mit der Betriebssystembibliothek verfügbar gemacht. Die Liste der verfügbaren Funktionen ist in der folgenden Tabelle aufgeführt.

Sr.Nr.	Bibliothek / Methode & Zweck
1	os.clock () Gibt eine Annäherung an die vom Programm verwendete CPU-Zeit in Sekunden zurück.
2	os.date ([format [, time]]) Gibt eine Zeichenfolge oder Tabelle mit Datum und Uhrzeit zurück, die gemäß dem angegebenen Zeichenfolgenformat formatiert ist.
3	os.difftime (t2, t1) Gibt die Anzahl der Sekunden vom Zeitpunkt t1 bis zum Zeitpunkt t2 zurück. In POSIX, Windows und einigen anderen Systemen ist dieser Wert genau t2-t1.
4	os.execute ([command]) Diese Funktion entspricht dem ANSI C-Funktionssystem. Es übergibt den Befehl, der von einer Betriebssystem-Shell ausgeführt werden soll. Das erste Ergebnis ist wahr, wenn der Befehl erfolgreich beendet wurde, oder andernfalls null.
5	os.exit ([code [, close]) Ruft den ANSI C-Funktionsexit auf, um das Hostprogramm zu beenden. Wenn der Code wahr ist, lautet der zurückgegebene Status EXIT_SUCCESS. Wenn der Code falsch ist, lautet der zurückgegebene Status EXIT_FAILURE. Wenn der Code eine Nummer ist, ist der zurückgegebene Status diese Nummer.
6	os.getenv (varname) Gibt den Wert der Prozessumgebungsvariablen varname oder nil zurück, wenn die Variable nicht definiert ist.
7	os.remove (filename) Löscht die Datei (oder das leere Verzeichnis auf POSIX-Systemen) mit dem angegebenen Namen. Wenn diese Funktion fehlschlägt, wird null sowie eine Zeichenfolge zurückgegeben, die den Fehler und den Fehlercode beschreibt.
8	os.rename (oldname, newname) Benennt die Datei oder das Verzeichnis mit dem Namen oldname in newname um. Wenn diese Funktion fehlschlägt, wird null sowie eine Zeichenfolge zurückgegeben, die den Fehler und den Fehlercode beschreibt.
9	os.setlocale (locale [, category]) Legt das aktuelle Gebietsschema des Programms fest. Das Gebietsschema ist eine systemabhängige Zeichenfolge, die ein Gebietsschema angibt. Kategorie ist eine optionale Zeichenfolge, die beschreibt, welche Kategorie geändert werden soll: "all", "collate", "ctype", "monetary", "numeric" oder "time"; Die Standardkategorie ist "alle". Die Funktion gibt den Namen des neuen Gebietsschemas zurück oder null, wenn die Anforderung nicht berücksichtigt werden kann.
10	os.time ([table]) Gibt die aktuelle Uhrzeit zurück, wenn sie ohne Argumente aufgerufen wird, oder eine Uhrzeit, die das in der angegebenen Tabelle angegebene Datum und die Uhrzeit darstellt. Diese Tabelle muss die Felder Jahr, Monat und Tag enthalten und kann die Felder Stunde (Standard ist 12), min (Standard ist 0), sec (Standard ist 0) und isdst (Standard ist null) enthalten. Eine Beschreibung dieser Felder finden Sie in der Funktion os.date.
11	os.tmpname () Gibt eine Zeichenfolge mit einem Dateinamen zurück, die für eine temporäre Datei verwendet werden kann. Die Datei muss vor ihrer Verwendung explizit geöffnet und explizit entfernt werden, wenn sie nicht mehr benötigt wird.

Allgemeine Betriebssystemfunktionen

Ein einfaches Beispiel mit allgemeinen mathematischen Funktionen ist unten dargestellt.

-- Date with format
io.write("The date is ", os.date("%m/%d/%Y"),"\n")

-- Date and time
io.write("The date and time is ", os.date(),"\n")

-- Time
io.write("The OS time is ", os.time(),"\n")

-- Wait for some time
for i=1,1000000 do
end

-- Time since Lua started
io.write("Lua started before ", os.clock(),"\n")

Wenn wir das obige Programm ausführen, erhalten wir eine ähnliche Ausgabe wie die folgende.

The date is 01/25/2014
The date and time is 01/25/14 07:38:40
The OS time is 1390615720
Lua started before 0.013

Die obigen Beispiele sind nur einige der gängigen Beispiele. Wir können die Betriebssystembibliothek je nach Bedarf verwenden. Versuchen Sie daher, alle Funktionen zu nutzen, um sich besser vertraut zu machen. Es gibt Funktionen wie Entfernen, die beim Entfernen von Dateien helfen, Ausführen, die uns beim Ausführen von Betriebssystembefehlen helfen, wie oben erläutert.