Alles wissen wollen. Lua-Sprache. Sehen Sie in anderen Wörterbüchern, was „Lua“ ist. Lua von Grund auf lernen
Lua-Skripte
Ein in Lua geschriebenes Skript hat keine spezielle Funktion, von der aus seine Ausführung beginnen würde. Ein Skript kann einfach als eine Reihe von Befehlen (Anweisungen) betrachtet werden, die ab der ersten Anweisung ausgeführt werden.
Das Skript kann entweder sehr einfach sein und nur aus einem Befehl bestehen, oder sehr komplex sein und Dutzende, Hunderte oder sogar Tausende von Anweisungen enthalten. Folgende Anweisungen können durch ein Semikolon (;) getrennt werden. Diese Anforderung ist jedoch nicht obligatorisch, sodass der gesamte folgende Code in Bezug auf die Syntax korrekt ist:
Arbeiten mit Variablen in Lua
Variablen werden verwendet, um Werte während der Skriptausführung zu speichern.
Variablennamen in Lua
Variablennamen (Bezeichner) in Lua können eine beliebige Folge von Buchstaben, Zahlen und Unterstrichen sein, die nicht mit einer Zahl beginnen.
beachten Sie
Die Lua-Sprache unterscheidet zwischen Groß- und Kleinschreibung, also sind abc, Abc, ABC unterschiedliche Namen.
Die folgende Tabelle listet Wörter auf, die von der Lua-Sprache reserviert sind und nicht in Variablennamen verwendet werden können:
and break do elseif
end false für Funktion if
in lokalen null nicht oder
repeat return then true until
Außerdem alle Namen, die mit einem gefolgten Unterstrich beginnen Großbuchstaben(zB _VERSION) sind ebenfalls reserviert.
Was sind die Variablen in Lua?
Variablen in Lua können entweder global oder lokal sein. Wenn eine Variable nicht explizit als lokal deklariert ist, wird sie als global betrachtet.
Lua Globale Variablen
Eine globale Variable erscheint in dem Moment, in dem ihr ihr erster Wert zugewiesen wird. Vor der Zuweisung des ersten Werts ergibt der Zugriff auf eine globale Variable null.
MsgBox(tostring(g)) --> nil
MsgBox(tostring(g)) --> 1
Die globale Variable existiert, solange die Skriptausführungsumgebung existiert, und steht jedem Lua-Code zur Verfügung, der in dieser Umgebung ausgeführt wird.
Bei Bedarf können Sie eine globale Variable explizit löschen, indem Sie sie einfach auf null setzen.
g = 1 - Erstellen Sie eine globale Variable g mit dem Wert 1
g = nil - entfernt die globale Variable g
MsgBox(tostring(g)) --> nil
Alle globalen Variablen sind Felder in einer regulären Tabelle, die als globale Umgebung bezeichnet wird. Diese Tabelle ist über die globale Variable _G verfügbar. Da die Felder der globalen Umgebung alle globale Variablen sind (einschließlich _G selbst), ist _G._G == _G.
Lokale Lua-Variablen
Alle lokalen Variablen müssen explizit mit dem Schlüsselwort local deklariert werden. Sie können überall im Skript eine lokale Variable deklarieren. Die Deklaration kann das Zuweisen eines Anfangswerts zu der Variablen umfassen. Wenn kein Wert zugewiesen wird, enthält die Variable null.
local a - deklariert die lokale Variable a
local b = 1 - lokale Variable b deklarieren, Wert 1 zuweisen
local c, d = 2, 3 - lokale Variablen c und d deklarieren, ihnen die Werte 2 und 3 zuweisen
Der Gültigkeitsbereich einer lokalen Variablen beginnt nach der Deklaration und dauert bis zum Ende des Blocks.
Notiz
Der Gültigkeitsbereich einer Variablen ist ein Abschnitt des Programmcodes, in dem Sie auf den in dieser Variablen gespeicherten Wert zugreifen können.
Sperren bedeutet:
Körper der Kontrollstruktur (if-then, else, for, while, repeat);
Funktionskörper;
ein Stück Code, das in den Schlüsselwörtern do...end eingeschlossen ist.
Wenn eine lokale Variable außerhalb eines Blocks definiert wird, erstreckt sich ihr Gültigkeitsbereich bis zum Ende des Skripts.
local i = 1 - Variable i ist innerhalb des Skripts lokal
während ich<= a do - цикл от 1 до 5
local a = i^2 - Variable a ist lokal innerhalb der While-Schleife
MsgBox(a) --> 1, 4, 9, 16, 25
MsgBox(a) -->
wenn i > 5 dann
local a - Variable a ist dann lokal drinnen
MsgBox(a) --> 10
MsgBox(a) --> 5 (bezieht sich hier auf global a)
local a = 20 - Variable a ist lokal innerhalb von do-end
MsgBox(a) --> 20
MsgBox(a) --> 5 (bezieht sich hier auf global a)
beachten Sie
Es wird empfohlen, nach Möglichkeit lokale Variablen anstelle von globalen zu verwenden. Dadurch wird eine Verschmutzung des globalen Namensraums vermieden und eine bessere Leistung erzielt (weil der Zugriff auf lokale Variablen in Lua etwas schneller ist als der Zugriff auf globale).
Lua-Datentypen
Welche Datentypen unterstützt die Sprache Lua?
Lua unterstützt die folgenden Datentypen:
1. Null (nichts). Entspricht dem Fehlen eines Wertes für eine Variable. Dieser Typ wird durch einen einzelnen Wert, nil, dargestellt.
2. Boolesch (logisch). Dieser Typ umfasst die Werte false (false) und true (true).
Beim Ausführen logischer Operationen wird der Wert nil als falsch behandelt. Alle anderen Werte, einschließlich der Zahl 0 und der leeren Zeichenfolge, werden als wahr behandelt.
3. Zahl (numerisch). Wird verwendet, um numerische Werte darzustellen.
Numerische Konstanten können einen optionalen Bruchteil und einen optionalen Dezimalexponenten haben, der durch die Zeichen „e“ oder „E“ angegeben wird. Ganzzahlige numerische Konstanten können mit dem Präfix 0x hexadezimal angegeben werden.
Beispiele für gültige numerische Konstanten: 3, 3.0, 3.1415926, 314.16e-2, 0xff.
4. Zeichenfolge (Zeichenfolge). Wird zur Darstellung von Zeichenfolgen verwendet.
Zeichenfolgenwerte werden als eine Folge von Zeichen angegeben, die in einfache oder doppelte Anführungszeichen eingeschlossen sind:
a = "Dies ist eine Zeichenfolge"
b = "das ist die zweite Zeile"
In doppelte Anführungszeichen eingeschlossene Zeichenfolgen können C-ähnliche Escape-Sequenzen interpretieren, die mit einem "\"-Zeichen (Backslash) beginnen:
\b (Leerzeichen),
\n (Zeilenvorschub),
\r (Wagenrücklauf);
\t (horizontaler Tabulator),
\\ (umgekehrter Schrägstrich);
\"" (doppeltes Anführungszeichen);
\" (einfaches Anführungszeichen).
beachten Sie
Ein Zeichen in einer Zeichenfolge kann auch durch seinen Code mit der Escape-Sequenz dargestellt werden:
wobei ddd eine Folge von nicht mehr als drei Ziffern ist.
Neben Anführungszeichen können auch doppelte eckige Klammern verwendet werden, um einen String zu definieren:
Wenn Sie einen String mit doppelten eckigen Klammern definieren, können Sie alle Escape-Sequenzen ignorieren, d. h. der String wird vollständig wie beschrieben erstellt:
lokales a = [] in Lua]=]
Es wird einen Begriff geben: "string[] definition in Lua"
5. Funktion (Funktion). Funktionen in Lua können in Variablen geschrieben, als Parameter an andere Funktionen übergeben und als Ergebnis der Ausführung von Funktionen zurückgegeben werden.
6. Tabelle (Tabelle). Eine Tabelle ist ein Satz von „Schlüssel“-„Wert“-Paaren, die als Felder oder Elemente einer Tabelle bezeichnet werden. Sowohl Schlüssel als auch Tabellenfeldwerte können von jedem Typ außer Null sein. Tabellen haben keine feste Größe: Sie können jederzeit beliebig viele Elemente hinzufügen.
Lesen Sie mehr im Artikel "Tabellen in Lua erstellen"
7. Benutzerdaten (Benutzerdaten). Es ist ein spezieller Datentyp. Werte dieses Typs können nicht direkt in einem Lua-Skript erstellt oder geändert werden.
Benutzerdaten werden verwendet, um neue Typen darzustellen, die im Aufrufer des Skripts oder in in C geschriebenen Bibliotheken erstellt wurden. Beispielsweise verwenden die Lua-Erweiterungsbibliotheken für "CronosPRO" diesen Typ, um Objekte wie die folgenden darzustellen:
Datenbanken (Klasse Bank);
Datenbanken (Klasse Base);
Aufzeichnungen (Klassenaufzeichnung) usw.
8. Faden (Faden). Entspricht dem Ausführungsablauf. Diese Streams sind in keiner Weise damit verbunden Betriebssystem und werden ausschließlich durch Lua selbst unterstützt.
Wie setze ich den Typ einer Variablen in Lua?
Lua gibt den Typ einer Variablen nicht explizit an. Der Typ einer Variablen wird zu dem Zeitpunkt festgelegt, zu dem der Variablen ein Wert zugewiesen wird. Jeder Variablen kann ein Wert beliebigen Typs zugewiesen werden (unabhängig davon, welchen Typ sie zuvor enthielt).
a = 123 - Variable a hat Typnummer
a = "123" - jetzt ist die Variable a vom Typ String
a = true - Variable a ist jetzt vom Typ boolean
a = () - jetzt ist die Variable a vom Typ Tabelle
beachten Sie
Variablen vom Typ Table, Function, Thread und Userdata enthalten nicht die Daten selbst, sondern speichern Verweise auf die entsprechenden Objekte. Beim Zuweisen, Übergeben an eine Funktion als Argument und Zurückkehren von einer Funktion als Ergebnis werden Objekte nicht kopiert, sondern nur Verweise auf sie kopiert.
a = () - Erstellen Sie eine Tabelle. In die Variable a wird ein Verweis auf die Tabelle gestellt
b = a - Variable b bezieht sich auf dieselbe Tabelle wie a
a = 10 - Tabellenelement mit Index 1 wird der Wert 10 zugewiesen
MsgBox(b) --> "10"
MsgBox(a) --> "20"
Die restlichen Daten sind Sofortwerte.
MsgBox(a) --> "20"
MsgBox(b) --> "10"
Wie erhalte ich den Typ einer Variablen in Lua?
Der Typ eines in einer Variablen gespeicherten Wertes kann mit Hilfe des Standardfunktionstyps ermittelt werden. Diese Funktion gibt einen String zurück, der den Namen des Typs enthält ("nil", "number", "string", "boolean", "table", "function", "thread", "userdata").
t = type("this is a string") - t ist gleich "string"
t = type(123) - t ist "Zahl"
t = Typ(Typ) - t ist gleich "Funktion"
t = type(true) - t ist "boolean"
t = type(nil) - t ist "nil"
t = type(CroApp.GetBank()) - t ist gleich "userdata"
Wie konvertiere ich den Typ einer Variablen in Lua?
Lua konvertiert bei Bedarf automatisch Zahlen in Zeichenfolgen und umgekehrt. Wenn beispielsweise ein Zeichenfolgenwert ein Operand in einer arithmetischen Operation ist, wird er in eine Zahl umgewandelt. Ebenso wird ein numerischer Wert, der dort angetroffen wird, wo eine Zeichenkette erwartet wird, in eine Zeichenkette konvertiert.
a = "10" + 2 - a ist gleich 12
a = "10" + 2 - a ist gleich "10 + 2"
a = "-5.3e-10"*"2" - a ist gleich -1.06e-09
a = "string" + 2 - Fehler! "String" kann nicht in Zahl konvertiert werden
Ein Wert eines beliebigen Typs kann mit der Standardfunktion tostring explizit in einen String konvertiert werden.
a = tostring(10) - a ist "10"
a = tostring(true) - a ist gleich "true"
a = tostring(nil) - a ist gleich "nil"
a = tostring (( = "this is field 1")) - a ist gleich "table: 06DB1058"
Aus dem vorherigen Beispiel können Sie sehen, dass die Inhalte der Tabellen nicht von der tostring-Funktion konvertiert werden. Diese Transformation kann mit der Render-Funktion durchgeführt werden.
a = render(10) - a ist "10"
a = render(true) - a ist gleich "true"
a = render(nil) - a ist "nil"
a = render (( = "this is field 1")) - a is "( = "this is field 1")"
Um einen Wert explizit in eine Zahl umzuwandeln, können Sie die Standardfunktion tonumber verwenden. Wenn der Wert ein String ist, der in eine Zahl konvertiert werden kann (oder bereits eine Zahl ist), gibt die Funktion das Ergebnis der Konvertierung zurück, andernfalls gibt sie nil zurück.
a = tonumber("10") - a ist gleich "10"
a = tonumber("10"..5") - a ist gleich 10,5
a = tonumber(true) - a ist gleich "nil"
a = tonumber (nil) - a ist gleich "nil"
Anordnung von Kommentaren in Lua
Ein Kommentar in Lua beginnt mit zwei Minuszeichen (--) und geht bis zum Ende der Zeile.
local a = 1 - einzeiliger Kommentar
Wenn direkt auf die „--“-Zeichen zwei öffnende eckige Klammern ([[) folgen, ist der Kommentar mehrzeilig und wird bis zu zwei schließenden eckigen Klammern (]]) fortgesetzt.
lokal a = 1 - [[ mehrzeilig
Kommentar ]]
Doppelte Klammern in Kommentaren können verschachtelt werden. Um sie nicht zu verwechseln, wird ein Gleichheitszeichen (=) zwischen die Klammern eingefügt:
lokal a = [[Kronos Company]] - [=[
local a = [[Kronos Company]]
Die Anzahl der "="-Zeichen bestimmt die Verschachtelung:
local a = [=[Definition einer Zeichenfolge [] in Lua]=] --[==[
local a = [=[Definition einer Zeichenfolge [] in Lua]=]
Operationen, die in Lua verwendet werden
In Ausdrücken, die in Lua geschrieben sind, können die folgenden Arten von Operationen verwendet werden:
1. Arithmetische Operationen.
Lua unterstützt die folgenden arithmetischen Operationen:
+ (Zusatz);
- (Subtraktion);
* (Multiplikation);
/ (Aufteilung);
^ (Potenzierung);
% (Rest der Division).
beachten Sie
Arithmetische Operationen sind sowohl auf Zahlen als auch auf Zeichenketten anwendbar, die in diesem Fall in Zahlen umgewandelt werden.
2. Vergleichsoperationen.
Die folgenden Wertvergleichsoperationen sind in Lua erlaubt:
== (gleich);
~= (nicht gleich);
< (меньше);
> (größer);
<= (меньше или равно);
>= (größer oder gleich).
beachten Sie
Vergleichsoperationen geben immer den booleschen Wert true oder false zurück.
Die Regeln zum Konvertieren von Zahlen in Zeichenketten (und umgekehrt) funktionieren bei Vergleichen nicht, d. h. der Ausdruck "0" == 0 ergibt falsch.
3. Logische Operationen.
Die logischen Operationen sind:
und (logisches UND).
Der and-Operator gibt seinen ersten Operanden zurück, wenn er als false oder nil ausgewertet wird. Andernfalls gibt die Operation den zweiten Operanden zurück (und dieser Operand kann einen beliebigen Typ haben).
a = (null und 5) - a ist gleich null
a == (falsch und 5) - a ist falsch
a == (4 und 5) - a ist gleich 5
oder (logisches ODER).
Der or-Operator gibt den ersten Operanden zurück, wenn er weder falsch noch nil ist, andernfalls gibt er den zweiten Operanden zurück.
a == (4 oder 5) - a ist gleich 4
a == (falsch oder 5) - a ist gleich 5
beachten Sie
Rätsel Operationen und und oder können Werte beliebigen Typs zurückgeben.
Die logischen Operationen und und oder werten den Wert des zweiten Operanden nur aus, wenn er zurückgegeben werden muss. Falls nicht benötigt, wird der zweite Operand nicht ausgewertet. Zum Beispiel:
a == (4 oder f()) - die Funktion f() wird nicht aufgerufen
nicht (logisches NICHT).
Der not-Operator gibt immer true oder false zurück.
4. Operation der Verkettung.
Verwenden Sie zum Verketten (Kombinieren) von Zeichenfolgen die Operation ... (zwei Punkte).
a = "Kronos".."-".."Inform" - Variable a erhält den Wert "Kronos-Inform"
beachten Sie
Wenn einer oder beide Operanden Zahlen sind, werden sie in Zeichenfolgen umgewandelt.
a = 0..1 - Variable a bekommt den Wert "01"
5. Die Operation zum Ermitteln der Länge.
Lua definiert den Längenoperator #, mit dem die Länge eines Strings ermittelt werden kann.
a = "Zeichenfolge"
len = #a - len ist gleich 6
len = #"one more line" - len ist 10
beachten Sie
Sie können auch den #-Operator verwenden, um den maximalen Index (oder die maximale Größe) eines Arrays herauszufinden. Weitere Einzelheiten finden Sie im Artikel „Arbeiten mit Arrays in Lua“.
Operatorvorrang in Lua
In Lua werden Operationen gemäß der folgenden Priorität (in absteigender Reihenfolge) ausgeführt:
2. nicht # - (unär)
6. < > <= >= ~= ==
Aufrufen von Skripten aus Formularen
Jedem Formular (einschließlich verschachtelten Formularen) ist ein separates Skript zugeordnet, das normalerweise Funktionen enthält, die die Ereignisse des Formulars und seiner Elemente behandeln.
Wenn ein Formular ausgeführt wird, wird sein Skript in die globale Umgebung geladen. Wenn ein Ereignis eines Formulars oder seines Elements eintritt, ruft das System die diesem Ereignis zugeordnete Behandlungsfunktion auf.
Es sollte beachtet werden, dass das Formularskript, obwohl es keinen Aufruf der Modulfunktion enthält, tatsächlich ein Modul ist. Das bedeutet, dass im Formularskript ohne das Schlüsselwort local deklarierte Variablen nicht der globalen Umgebung ausgesetzt sind und nur innerhalb dieses Skripts verfügbar sind. Wenn ein Wert anderen Formularskripten zur Verfügung gestellt werden soll, muss er explizit in der globalen _G-Tabelle definiert werden:
lokal a = _G.var
Anweisungsblöcke (Anweisungen)
Die wichtigsten Lua-Operatoren sind:
Abtretung;
Bedingungsoperator;
Operatoren für die Organisation von Zyklen.
Eine Gruppe von Anweisungen kann mit dem Konstrukt do...end zu einem Block (zusammengesetzte Anweisung) zusammengefasst werden.
do - der Anfang des Blocks
<оператор1>- Blockkörper
<оператор2>
<операторN>
end - das Ende des Blocks
Der Block öffnet einen neuen Bereich, in dem Sie lokale Variablen definieren können.
a = 5 - globale Variable a
local a = 20 - lokale Variable a ist innerhalb von do-end definiert
MsgBox(a) --> 20
MsgBox(a) --> 5 (hier ist der Verweis bereits auf das globale a)
Zuweisungsoperator in Lua
Eine Zuweisung ändert den Wert einer Variablen oder eines Tabellenfeldes. In seiner einfachsten Form könnte eine Zuweisung so aussehen:
a = 1 - der Variablen a wird der Wert 1 zugewiesen
a = b + c - der Variablen a wird die Summe der Werte der Variablen b und c zugewiesen
a = f(x) - der Variablen a wird der von der Funktion f(x) zurückgegebene Wert zugewiesen
In Lua ist die sogenannte Mehrfachzuweisung erlaubt, wenn mehrere Variablen links vom Zuweisungsoperator die Werte mehrerer rechts vom Zuweisungsoperator geschriebener Ausdrücke erhalten:
a, b = 1, 5*c - a ist gleich 1; b ist gleich 5*c
Wenn es mehr Variablen als Werte gibt, wird "zusätzlichen" Variablen null zugewiesen.
a, b, c = 1, 2 - a ist gleich 1; b ist 2; c ist gleich null
Wenn es mehr Werte als Variablen gibt, werden die "zusätzlichen" Werte ignoriert.
a, b = 1, 2, 3 - a ist gleich 1; b ist 2; Wert 3 nicht verwendet
Durch Mehrfachzuweisung können Werte zwischen Variablen ausgetauscht werden:
a = 10; b = 20 - a ist 10, b ist 20
a, b = b, a - jetzt ist a 20, b ist 10
Bedingte Anweisung (if) in Lua
Die if-Anweisung testet die Wahrheit einer gegebenen Bedingung. Wenn die Bedingung wahr ist, wird der Teil des Codes nach dem Schlüsselwort then (then-Abschnitt) ausgeführt. Andernfalls wird der Code nach dem Schlüsselwort else (Abschnitt else) ausgeführt.
wenn a > b dann
gib a zurück - wenn a größer als b ist, gib a zurück
gib b zurück - andernfalls gib b zurück
Der Else-Abschnitt ist optional.
wenn ein< 0 then
a = 0 - wenn a kleiner als 0 ist, setze a auf 0
Sie können das elseif-Konstrukt anstelle von verschachtelten if-Anweisungen verwenden. Zum Beispiel der folgende Code:
Es ist einfacher zu lesen, wenn Sie es durch Folgendes ersetzen:
Rückgabe "Ivan" - wenn a gleich 1 ist
sonst wenn a == 2 dann
gib "Peter" zurück - wenn a 2 ist
sonst wenn a == 3 dann
gib "Sergey" zurück - wenn a gleich 3 ist
return "No such player" - wenn a keiner der aufgelisteten ist
Schleife mit Vorbedingung (while) in Lua
Die while-Anweisung dient zum Organisieren von Zyklen mit einer Vorbedingung und hat die folgende Form:
während
... - Schleifenkörper
Vor jeder Iteration der Schleife wird die Bedingung überprüft
wenn die Bedingung falsch ist, wird die Schleife beendet und die Kontrolle an die erste Anweisung nach der while-Anweisung übergeben;
Wenn die Bedingung wahr ist, wird der Schleifenkörper ausgeführt, wonach alle Aktionen wiederholt werden.
while i > 0 do - Schleife von 10 nach 1
t[i] = "Feld"..i
a = (3, 5, 8, -6, 5)
while i > 0 do - suchen Sie nach einem negativen Wert im Array
wenn ein [ich]< 0 then break end - если найдено, прерываем цикл
i = i - 1 - andernfalls gehe zum nächsten Element
wenn i > 0 dann
MsgBox("Negativer Wertindex: "..i)
MsgBox("Das Array enthält keine negativen Werte")
Notiz
Schleife mit Nachbedingung (Wiederholung) in Lua
Der Wiederholungsoperator dient zum Organisieren von Zyklen mit einer Nachbedingung und hat die folgende Form:
... - Schleifenkörper
bis um
Der Schleifenkörper wird bis zur Bedingung ausgeführt
Summieren Sie die Werte des Arrays a, bis die Summe 10 überschreitet
a = (3, 2, 5, 7, 9)
summe = summe + a[i]
bis Summe > 10
MsgBox("Added ..i.." items. Sum equals "..sum)
Sie können die break-Anweisung verwenden, um eine Schleife zu verlassen, bevor sie endet.
Notiz
Weitere Informationen zu den Funktionen der Break-Anweisung finden Sie im Artikel „Break- und Return-Anweisungen“.
Schleifen mit einer for-Anweisung in Lua
Die for-Anweisung ist zum Organisieren von Schleifen gedacht und erlaubt zwei Schreibweisen:
einfach (numerisch für);
erweitert (universal für).
einfache Form zur Aussage
Die einfache Form der for-Anweisung lautet wie folgt:
für var = exp1, exp2, exp3 tun
... - Schleifenkörper
Der Schleifenkörper wird für jeden Wert der Schleifenvariablen (Zähler) var im Bereich von exp1 bis exp2 mit einem Schritt von exp3 ausgeführt.
Notiz
Der Schritt darf nicht angegeben werden. In diesem Fall wird es gleich 1 genommen.
for i = 1, 10 do - Schleife von 1 bis 10 mit Schritt 1
MsgBox("i ist gleich"..i)
for i = 10, 1, -1 do - Schleife von 10 nach 1 mit Schritt -1
MsgBox("i ist gleich"..i)
beachten Sie
Die Ausdrücke exp1, exp2 und exp3 werden nur einmal vor Beginn der Schleife ausgewertet. Im Beispiel unten wird die Funktion f(x) also nur einmal aufgerufen, um die Obergrenze der Schleife zu berechnen:
for i = 1, f(x) do - Schleife von 1 zu dem von f() zurückgegebenen Wert
MsgBox("i ist gleich"..i)
Die Schleifenvariable ist lokal für die Schleifenanweisung und wird am Ende der Schleife nicht definiert.
for i = 1, 10 do - Schleife von 1 zu dem von f() zurückgegebenen Wert
MsgBox("i ist gleich"..i)
MsgBox("Nach Verlassen der Schleife ist i gleich "..i") - Falsch! i gleich null
beachten Sie
Der Wert einer Schleifenvariablen kann nicht innerhalb der Schleife geändert werden: Die Folgen einer solchen Änderung sind unvorhersehbar.
Die break-Anweisung wird verwendet, um die Schleife zu verlassen, bevor sie beendet ist.
a = (3, 5, 8, -6, 5)
for i = 1,#a do - suchen Sie nach einem negativen Wert im Array
wenn ein [ich]< 0 then - если найдено...
index = i - speichert den Index des gefundenen Wertes...
break - und die Schleife unterbrechen
MsgBox("Negativer Wertindex: "..index)
Notiz
Weitere Informationen zu den Funktionen der Break-Anweisung finden Sie im Artikel "Break- und Return-Anweisungen")
LUÁ, iau, vb. I. trans. I. 1. A prinde un obiect în mână spre a l ţine (şi a se servi de el) sau spre a l pune în altă parte. ♢ erw. A lua altă vorbă = a schimba (cu dibăcie) subiectul unei discuţii. A(şi) lua picioarele la spinare = ein Pleca… … Dicționar Român
Lua- Logo Basisdaten Paradigmen: Skriptsprache, imperativ, funktional, objektorientiert … Deutsch Wikipedia
Lua- [] Información general Paradigma Multiparadigma: interpretado, imperativo, funcional, orientado a objetos, basado en prototipos Apareció en … Wikipedia Español
LUA- Apparu en 1993 Autor Luiz Henrique de Figueiredo, Roberto Ierusalimschy und Waldemar Celes Implementierungen von Lua, LuaJIT, LLVM Lua, LuaCLR, Nua, Lua A ... Wikipedia in Französisch
LUA- (Portugiesisch für Mond) ist eine Skriptsprache zum Einbinden in Programme, um diese leichter zu entwickeln und zu warten. Eine der besonderen Eigenschaften von Lua ist die geringe Größe des kompilierten Skript-Interpreters. Lua wurde… … English Wikipedia
Lua- s. f. 1. O unico planeta satélite da Terra. 2. Tempo compreendido entre dois novilúnios. 3. Mês. 4.Cio. 5. O mesmo que peixe lua. 6. Disco de ouro ou prata que os Timores usam ao pescoço, como símbolo de… … Dicionario da Lingua Portugiesisch
Lua- kann sich beziehen auf: * Lua (Programmiersprache), eine leichte, erweiterbare Programmiersprache * Lua (Yu Gi Oh! 5D s) * Lua (Göttin), die römische Göttin * Lua (Kampfkunst), eine traditionelle hawaiianische Kampfkunst * Lua (Lied), eine Single aus dem Folkrock… … Wikipedia
LUA-Abkürzung: LUA last universal ancestor (auch übersetzt als „Last universal ancestor“ (engl. LUA, Last Universal Ancestor), sonst Last universal common ancestor (engl. LUCA, last universal common ... ... Wikipedia
Lua- (Del gót. lôfa, palma de la mano). 1. f. Especie de guante hecho de esparto y sin separaciones para los dedos, que sirve para limpiar las caballerías. 2. Mär. Revés de las velas por la parte donde van cazadas con viento largo o en popa. 3. Mär.… … Diccionario de la lengua española
Lua- Lua, römische Göttin, Tochter des Saturnus, welcher nach der Schlacht zur Sühne des vergossenen Blutes erbeutete Waffen von dem Feldherrn verbrannt wurden … Pierer's Universal-Lexikon
LUA- Dea quaedam apud vett, a luendo, expiandoque nomen sortita, quae praeerat lustrationibus, et lustris. Siehe Turneb. Adver s. l. 16.c. 20. etl. 23.c. 23. etl. 19.c. 11. Eius meminit A. Gell. l. 13.c. 22. cum ait in Libris Sacerdotum Pop. Rom … Hofmann J. Lexicon universale
Bücher
- Lua-Programmierung
- Programmieren in der Sprache Lua. Führer, Jerusalem zu Robert. Das Buch widmet sich einer der beliebtesten eingebetteten Sprachen – Lua. Diese Sprache wurde in vielen Spielen und vielen verschiedenen Anwendungen verwendet. Die Sprache kombiniert ein kleines Volumen ...
Ich bin ein sentimentaler Programmierer. Manchmal verliebe ich mich in Programmiersprachen und kann dann stundenlang darüber reden. Ich werde eine dieser Stunden mit Ihnen teilen.
Lua? Was ist das?
Lua ist eine einfache einbettbare Sprache (sie kann in Ihre Programme integriert werden, die in anderen Sprachen geschrieben sind), leicht und verständlich, mit einem einzigen Datentyp und einer einheitlichen Syntax. Die perfekte Sprache zum Lernen.
Wozu?
Lua kann für Sie nützlich sein:
* Wenn Sie ein Spieler sind (Plugins für World of Warcraft und viele andere Spiele)
* wenn Sie Spiele schreiben (sehr oft in Spielen ist die Engine in C / C ++ und AI - in Lua geschrieben)
* wenn Sie ein Systemprogrammierer sind (Sie können Plugins für Nmap, Wireshark, Nginx und andere Dienstprogramme in Lua schreiben)
* wenn Sie ein Embedded-Entwickler sind (Lua ist sehr schnell, kompakt und benötigt nur sehr wenige Ressourcen)
1. Programmieren lernen. Zumindest ein Bisschen. Es spielt keine Rolle, welche Sprache.
2. Installieren Sie Lua. Laden Sie dazu entweder die Version 5.2 hier herunter (http://www.lua.org/download.html) oder suchen Sie in den Repositories danach. Version 5.1 wird auch funktionieren, aber seien Sie sich bewusst, dass es sehr alt ist.
Führen Sie alle Beispiele aus dem Artikel im Terminal mit einem Befehl wie "lua file.lua" aus.
Erste Eindrücke
Lua ist eine dynamisch typisierte Sprache (Variablen erhalten abhängig von den zugewiesenen Werten spontan Typen). Sie können darauf sowohl im imperativen als auch im objektorientierten oder funktionalen Stil schreiben (auch wenn Sie nicht wissen, wie es ist, ist es in Ordnung, lesen Sie weiter). Hier ist Hallo Welt in Lua:
Meine erste Lua-App: hello.lua print "hello world"; print("Auf Wiedersehen Welt")
Was lässt sich über die Sprache sagen:
* Einzeilige Kommentare beginnen mit zwei Bindestrichen "--"
* Klammern und Semikolons können weggelassen werden
Sprachoperatoren
Die Menge der bedingten Anweisungen und Schleifen ist ziemlich typisch:
Bedingte Anweisungen (es darf keinen Else-Zweig geben) if a == 0 then print("a is zero") else print("a is not zero") end -- Kurzform if/elseif/end (statt switch/ case) if a == 0 then print("zero") elseif a == 1 then print("one") elseif a == 2 then print("two") else print("other") end -- count loop for i = 1, 10 do print(i) end -- loop with precondition b = 5 while b > 0 do b = b - 1 end -- loop with postcondition repeat b = b + 1 until b >= 5
THINK: was könnte die Schleife "for i = 1, 10, 2 do ... end" bedeuten?
In Ausdrücken können Sie die folgenden Operatoren für Variablen verwenden:
* Zuweisung: x = 0
* Arithmetik: +, -, *, /, % (Rest), ^ (Potenzierung)
* logisch: und, oder, nicht
* Vergleich: >,<, ==, <=, >=, ~= (ungleich, ja-ja, statt dem üblichen "!=")
* Zeichenfolgenverkettung (Operator „..“), zB: s1="hello"; s2="Welt"; s3=s1..s2
* Länge/Größe (#-Operator): s="hello"; a = #s ('a' wird gleich 5 sein).
* Element nach Index abrufen, zB: s
Lange Zeit gab es keine Bitoperationen in der Sprache, aber in Version 5.2 erschien die bit32-Bibliothek, die sie implementiert (als Funktionen, nicht als Operatoren).
Datentypen
Ich habe Sie angelogen, als ich sagte, dass die Sprache einen Datentyp hat. Es hat viele davon (wie jede ernsthafte Sprache):
* null (absolut nichts)
* Boolesche Zahlen (wahr/falsch)
* Zahlen (Zahlen) - ohne Unterteilung in Ganzzahlen / Real. Nur Zahlen.
* Strings - übrigens sind sie den Strings in Pascal sehr ähnlich
* Funktionen - ja, die Variable kann vom Typ "Funktion" sein
* Faden
* beliebige Daten (Benutzerdaten)
* Tisch
Wenn mit den ersten Typen alles klar ist, was sind dann Benutzerdaten? Denken Sie daran, dass Lua eine einbettbare Sprache ist und normalerweise eng mit Programmkomponenten zusammenarbeitet, die in anderen Sprachen geschrieben sind. Diese "fremden" Komponenten können also Daten für ihre eigenen Bedürfnisse erstellen und diese Daten zusammen mit Lua-Objekten speichern. Benutzerdaten sind also der Unterwasserteil des Eisbergs, der aus Sicht der Lua-Sprache nicht benötigt wird, aber wir können ihn einfach nicht ignorieren.
Und jetzt das Wichtigste in der Sprache - Tabellen.
Tische
Ich habe Sie wieder angelogen, als ich sagte, dass die Sprache 8 Datentypen hat. Sie können davon ausgehen, dass es sich um eins handelt: Alles sind Tabellen (das stimmt übrigens auch nicht). Eine Tabelle ist eine sehr elegante Datenstruktur, sie kombiniert die Eigenschaften eines Arrays, einer Hash-Tabelle („Schlüssel“ - „Wert“), einer Struktur, eines Objekts.
Hier ist also ein Beispiel einer Tabelle als Array: a = (1, 2, 3) -- ein Array aus 3 Elementen print(a) -- gibt "2" aus, weil die Indizes von eins an gezählt werden -- And the table hat die Form eines Sparse-Arrays (das nicht alle Elemente enthält) a = () -- leere Tabelle a = 1 a = 5
THINK: Was ist a im Fall eines Sparse-Arrays?
Im obigen Beispiel verhält sich die Tabelle wie ein Array, aber in Wirklichkeit haben wir Schlüssel (Indizes) und Werte (Array-Elemente). Und gleichzeitig können Schlüssel jeden Typs haben, nicht nur Zahlen:
A = () a["hello"] = true a["world"] = false a = 1 -- oder so: a = ( hello = 123, world = 456 ) print(a["hello")) print ( a.hello) ist dasselbe wie a["hello"], obwohl es wie eine Struktur mit Feldern aussieht
Da die Tabelle übrigens Schlüssel und Werte hat, können Sie alle Schlüssel und ihre entsprechenden Werte in einer Schleife durchlaufen:
T = ( a = 3, b = 4 ) for key, value in pairs(t) do print(key, value) -- druckt "a 3", dann "b 4" end
Aber was ist mit Objekten? Wir werden sie etwas später zuerst kennenlernen - über Funktionen.
Funktionen
Hier ist ein Beispiel für eine reguläre Funktion.
Funktion add(a, b) return a + b end print(add(5, 3)) -- print "8"
Die Sprachfunktionen ermöglichen es Ihnen, mehrere Argumente zu nehmen und mehrere Argumente zurückzugeben. Daher werden Argumente, deren Werte nicht explizit angegeben sind, als gleich Null betrachtet.
THINK: Warum möchten Sie mehrere Argumente zurückgeben?
Funktion swap(a, b) return b, a end x, y = swap(x, y) -- das geht übrigens auch ohne Funktion: x, y = y, x -- und wenn die Funktion zurückkehrt mehrere Argumente, -- Sie brauchen sie nicht - ignorieren Sie sie mit der -- speziellen Unterstrich-Variable "_" a, _, _, d = some_function()
Funktionen können eine variable Anzahl von Argumenten annehmen:
Im Prototyp wird die variable Anzahl der Argumente als Ellipsenfunktion sum(...) s = 0 for _, n in pairs(arg) do geschrieben -- in der Funktion werden sie als Tabelle "arg" s bezeichnet = s + n end gibt ein Ende zurück sum(1, 2, 3) -- gibt 6 zurück sum(1, 2, 3, 4) -- gibt 10 zurück
Da Funktionen ein vollwertiger Datentyp sind, können Sie Funktionsvariablen erstellen oder Funktionen als Argumente an andere Funktionen übergeben
A = function(x) return x * 2 end -- Funktion, die mit 2 multipliziert b = function(x) return x + 1 end -- Funktion, die um 1 erhöht wird function apply(table, f) result = () for k, v in Paaren(Tabelle) do result[k] = f(v) -- Ersetze das Element durch irgendeine Funktion dieses Elements end end -- DENKE: was t = (1, 3, 5) aufruft apply(t, a) anwenden (t, b)
Objekte = Funktionen + Tabellen
Da wir Funktionen in Variablen speichern können, können wir sie auch in Tabellenfeldern speichern. Und es entpuppt sich bereits als Als-ob-Methode. Für diejenigen, die mit OOP nicht vertraut sind, möchte ich sagen, dass sein Hauptvorteil (zumindest in Lua) darin besteht, dass die Funktionen und die Daten, mit denen sie arbeiten, in der Nähe sind – innerhalb desselben Objekts. Für diejenigen, die mit OOP vertraut sind, werde ich sagen, dass es hier keine Klassen und Prototyp-Vererbung gibt.
Kommen wir zu den Beispielen. Wir haben ein Objekt, sagen wir eine Glühbirne. Sie weiß, wie man brennt und nicht brennt. Nun, es gibt zwei Aktionen, die Sie damit machen können - schalten Sie es ein und aus:
Lamp = ( on = false ) function turn_on(l) l.on = true end function turn_off(l) l.on = false end -- dies sind nur Funktionen für die Arbeit mit der turn_on(lamp) turn_off(lamp) Struktur
Und wenn die Glühbirne zu einem Objekt gemacht wird und die Funktionen turn_off und turn_on zu Feldern des Objekts gemacht werden, dann erhalten wir:
Lamp = ( on = false turn_on = function(l) l.on = true end turn_off = function(l) l.on = false end ) lamp.turn_on(lamp) lamp.turn_off(lamp)
Wir sind gezwungen, das Glühbirnenobjekt selbst als erstes Argument zu übergeben, da unsere Funktion sonst nicht weiß, mit welcher Glühbirne sie arbeiten soll, um den Ein-/Aus-Zustand zu ändern. Aber um nicht ausführlich zu sein, hat Lua eine Abkürzung, die normalerweise verwendet wird - lamp:turn_on (). Insgesamt kennen wir bereits mehrere solcher Syntaxvereinfachungen:
lamp:turn_on() -- die gebräuchlichste Schreibweise lamp.turn_on(lamp) -- auch syntaktisch korrekt lamp["turn_on"](lamp) -- and this
Um weiter über Abkürzungen zu sprechen, Funktionen können nicht nur explizit als Felder einer Struktur beschrieben werden, sondern auch in einer bequemeren Form:
Lamp = ( on = false ) -- durch einen Punkt, dann muss das Argument angegeben werden function lamp.turn_on(l) l.on = true end -- durch Doppelpunkte, dann wird das Argument implizit selbst gesetzt, als Variable "self " -- "self" - und da ist die Glühbirne, für die die Methode lamp:turn_off() aufgerufen wurde self.on = false end
Interessant?
Besondere Merkmale
Einige Tabellenfunktionsnamen (Methoden) sind reserviert und haben eine besondere Bedeutung:
* __add(a, b), __sub(a, b), __div(a, b), __mul(a, b), __mod(a, b), __pow(a, b) - werden aufgerufen, wenn arithmetische Operationen durchgeführt werden auf Tisch
* __unm(a) - unäre Operation "minus" (wenn sie etwas wie "x = -x" schreiben)
* __lt(a, b), __le(a, b), __eq(a, b) - berechnet das Vergleichsergebnis (<, <=, ==)
* __len(a) - wird aufgerufen, wenn "#a" fertig ist
* __concat(a, b) - aufgerufen bei "a..b"
* __call(a, …) — aufgerufen bei „a()“. Variable Argumente sind Argumente, wenn sie aufgerufen werden
* __index(a, i) - Zugriff auf a[i], sofern ein solches Element nicht existiert
* __newindex(a, i, v) - erzeuge "a[i] = v"
* __gc(a) - wenn ein Objekt durch Garbage Collection entfernt wird
Durch Überschreiben dieser Methoden können Sie Operatoren überladen und die Syntax der Sprache für Ihre eigenen Zwecke verwenden. Die Hauptsache ist, es nicht zu übertreiben.
Nachlass
Für diejenigen, die OOP nicht kennen, ermöglicht die Vererbung die Erweiterung der Funktionalität einer bereits vorhandenen Klasse. Beispielsweise kann nur eine Glühbirne ein- und ausgeschaltet werden, und eine Super-Glühbirne ändert auch ihre Helligkeit. Warum müssen wir die turn_on/turn_off-Methoden neu schreiben, wenn wir sie wiederverwenden können?
In Lua gibt es dafür ein Konzept einer Metatabelle, d.h. Ahnentafel. Jede Tabelle hat eine übergeordnete Tabelle, und die untergeordnete Tabelle kann alles tun, was die übergeordnete Tabelle tun kann.
Nehmen wir an, wir haben das Lampentischobjekt bereits erstellt. Dann sieht die Superbirne so aus:
Superlamp = ( Brightness = 100 ) -- spezifizieren Sie die übergeordnete Tabelle setmetatable(superlamp, lamp) -- und ihre Methoden sind jetzt verfügbar superlamp:turn_on() superlamp:turn_off()
Funktionserweiterung
Viele Typen haben übergeordnete Tabellen (na ja, Strings und Tabellen, Zahlen und Boolesche Werte, und nil hat sie nicht). Angenommen, wir möchten alle Zeichenfolgen mit dem Operator "+" hinzufügen, nicht mit ".." . Dazu müssen Sie die Funktion "+" (__add) für die übergeordnete Tabelle aller Zeilen ersetzen:
S = getmetatable("") -- hat die übergeordnete Tabelle der Zeile s.__add = function(s1, s2) return s1..s2 end -- hat die Methode geändert -- check a = "hello" b = "world" print(a + b) -- schreibe "helloworld"
Eigentlich können wir die Druckfunktion immer noch durch "print = myfunction" ersetzen, und viele andere hackige Dinge können getan werden.
Bereiche
Variablen sind entweder global oder lokal. Nach der Erstellung sind alle Variablen in Lua global.
DENKE: Warum?
Um den lokalen Geltungsbereich anzugeben, schreiben Sie das Schlüsselwort local:
Lokal x Lokal var1, var2 = 5, 3
Vergiss dieses Wort nicht.
Fehlerverarbeitung
Wenn Fehler auftreten, ist es oft notwendig, die Ausführung einer bestimmten Funktion zu stoppen. Sie können natürlich viele Überprüfungen durchführen und "Rückgabe" anrufen, wenn etwas schief gelaufen ist. Dies erhöht jedoch die Codemenge. Lua verwendet so etwas wie Ausnahmen.
Fehler werden mit der error(x)-Funktion generiert. Als Argument kann alles übergeben werden (was mit dem Fehler zusammenhängt – eine String-Beschreibung, ein numerischer Code, ein Objekt, bei dem ein Fehler aufgetreten ist usw.)
Normalerweise stürzt nach dieser Funktion das ganze Programm ab. Und das ist nicht immer notwendig. Wenn Sie eine Funktion aufrufen, die einen Fehler auslösen könnte (oder ihre untergeordneten Funktionen einen Fehler auslösen könnten), rufen Sie sie sicher mit pcall() auf:
Funktion f(x, y) ... if ... then error("failed to do something") end ... end status, err = pcall(f, x, y) -- f: function, x-y: its Argumente if not status then -- handle err error. In unserem Fall enthält err den Fehlertext end
Standardbibliotheken
Es gibt viele nicht standardmäßige Bibliotheken, sie können auf LuaForge, LuaRocks und anderen Repositories gefunden werden.
Zwischen Lua und Nicht-Lua
Was aber, wenn uns die Funktionalität der Standardbibliotheken nicht ausreicht? Was ist, wenn wir unser C-Programm haben und seine Funktionen von Lua aus aufrufen möchten? Dafür gibt es einen ganz einfachen Mechanismus.
Nehmen wir an, wir wollen unsere eigene Funktion erstellen, die eine Zufallszahl zurückgibt (Lua hat math.random(), aber wir wollen lernen). Wir müssen den folgenden C-Code schreiben:
#enthalten
Diese. Lua stellt uns Funktionen zur Verfügung, um mit Datentypen zu arbeiten, Funktionsargumente zu nehmen und Ergebnisse zurückzugeben. Es gibt sehr wenige Funktionen, und sie sind ziemlich einfach. Jetzt bauen wir unsere Bibliothek als dynamische Bibliothek auf und können die Funktion rand() verwenden:
Random = require("librand") -- lädt die Bibliothek print(random.rand(1, 100)) print(random.rand(0, 1))
Was ist, wenn wir Lua-Code aus unseren Programmen aufrufen möchten? Dann sollen unsere Programme eine virtuelle Lua-Maschine erstellen, in der Lua-Skripte ausgeführt werden. Es ist viel einfacher:
#include "lua.h" #include "lauxlib.h" int main() ( lua_State *L = lua_open(); // die virtuelle Lua-Maschine erstellen luaL_openlibs(L); // die Standardbibliotheken laden luaL_dofile(L, " rand. lua"); // Skript ausführen lua_close(L); // Lua schließen return 0; )
Alle.
Sie können jetzt in Lua schreiben. Wenn Sie interessante Punkte über Lua erfahren, die sich im Artikel widerspiegeln könnten - schreiben Sie!
In dieser Reihe von Tutorials, die ich konzipiert habe, wird die Programmiersprache Lua besprochen. Ich werde versuchen, die Präsentation für Anfänger so zugänglich wie möglich zu machen, und ich werde mich auf sie konzentrieren. Das heißt, erfahrene Lua-Codierer werden hier höchstwahrscheinlich nichts Neues lernen (ich bin sicher, sie werden hier nur Platz für Spitzfindigkeiten und Kommentare finden, die ihrerseits sogar willkommen sind), aber wenn Sie haben keine reichhaltige Programmiererfahrung hinter sich, dann denke ich, dass Sie etwas bekommen werden.Die ganze Serie wird keinem System gehorchen. Die Lektionen werden nacheinander eine Reihe von Sprachkonstrukten einführen, sodass Sie in der dritten oder vierten Lektion bereits Ihre Programme schreiben können. Mein Ziel ist es, Sie dazu zu bringen, die Sprache selbst zu lernen, Ihnen dabei zu helfen, sie zu fühlen, und nicht, sie von A bis Z zu erklären - wenn Sie die Sprache vollständig beherrschen möchten, lesen Sie das Referenzhandbuch (das, wenn auch schlecht, übersetzt ist ins Russische: http://www.lua.ru/doc/). Je früher Sie von den „für Dummies“-Tutorials im Web zum Handbuch wechseln, desto besser.
Wenn etwas nicht klar ist, stellen Sie unbedingt eine Frage in den Kommentaren, und ich und andere Teilnehmer werden versuchen, Ihnen zu helfen.
Lua ist eine beliebte, leicht zu erlernende, universell einsetzbare, integrierbare, interpretierte, dynamisch typisierte Programmiersprache. Nein, Sie müssen nicht einmal die Hälfte der Wörter im vorherigen Satz verstehen - Hauptsache, es ist beliebt und unkompliziert. Übrigens, Einfachheit sowie die geringe Größe der Distribution (ca. 150 Kilobyte) verdienten seine Popularität. Lua-Scripting wird von einer Vielzahl von Anwendungen unterstützt, einschließlich Spielen. World of Warcraft und S.T.A.L.K.E.R. Verwenden Sie die Lua-Sprache. Meine Lieblingsspiel-Engine ermöglicht es Ihnen, mit Lua ganz einfach eine Vielzahl von Spielen zu erstellen. Wie Sie sehen, eröffnet Ihnen Lua viele Horizonte!
Bevor wir beginnen, sollten Sie eine Programmierumgebung einrichten: das heißt, ein Programm finden, das den von Ihnen geschriebenen Lua-Code übernimmt und ausführt: einen Interpreter. Hier gibt es drei Möglichkeiten:
1. Laden Sie die offizielle Lua-Distribution von einer der Seiten herunter, die sie anbieten.
Von der offiziellen Website von Lua können Sie nur die Quellcodes des Interpreters herunterladen. Wenn Sie sich jedoch http://lua.org/download.html im Abschnitt „Binärdateien“ ansehen, finden Sie möglicherweise Links zu Websites mit ausführbaren Windows-Dateien. Einer von ihnen: . Laden Sie eines der Archive von dort herunter (passend zu Ihrer Plattform: Win32 oder Win64) und entpacken Sie es irgendwo, vorzugsweise in ein Verzeichnis mit einem kurzen Pfad: wie C:\lua. Von nun an gehe ich davon aus, dass Sie Windows verwenden und Ihr Interpreter sich dort befindet.
Benutzer von Linux-basierten Betriebssystemen haben es in diesem Sinne einfacher: Sie müssen nur den Paketmanager verwenden und Lua aus den Repositories installieren. Bei Debian und Ubuntu geschieht dies mit apt-get install lua und bei Fedora, Red Hat und Derivaten mit yum install lua. Vertrauen Sie mir jedoch nicht blind und schlagen Sie im Handbuch Ihres Betriebssystems nach, um genau herauszufinden, wie es für Sie gemacht wird.
2. Verwenden Sie einen Online-Dolmetscher.
Zu finden unter http://www.lua.org/demo.html . Am Anfang mag es ausreichen, aber in Zukunft, wenn wir die Module berühren, werden Sie gezwungen sein, die Offline-Version zu verwenden. Die Verwendung des Online-Interpreters ist sehr einfach: Geben Sie Ihr Programm in das Textfeld ein und klicken Sie auf die Schaltfläche Ausführen. Das Programm wird ausgeführt, die Ausgabe Ihres Programms erscheint im Ausgabefenster, sowie eventuelle Fehlermeldungen von Ihnen.
3. Verwenden Sie eine IDE.
Zum Beispiel ZeroBrane Studio: http://studio.zerobrane.com/ . Es gibt andere - schauen Sie online.
Derzeit werden zwei leicht unterschiedliche Versionen von Lua verwendet: 5.1 und 5.2. Ich werde mich auf die neueste Version konzentrieren - Version 5.2, aber unbedingt auf wichtige Unterschiede zwischen ihr und 5.1 hinweisen, da letztere ebenfalls weit verbreitet ist. Übrigens, Lua 5.1 führt Code eineinhalb Mal schneller aus als Lua 5.2, nur damit Sie es wissen.
=== Lektion Nr. 1 ===
Fangen wir also an. Erstellen Sie eine main.lua-Datei in einem von fremden Dateien isolierten Ordner und schreiben Sie darin:
200?"200px":""+(this.scrollHeight+5)+"px");">
-- main.lua --
print("Hallo Welt!")
Führen Sie dann auf der Befehlszeile aus (vergessen Sie nicht, mit dem Befehl cd in das Verzeichnis mit main.lua zu wechseln):
200?"200px":""+(this.scrollHeight+5)+"px");">
> C:\lua\lua.exe main.lua
Als Antwort gibt der Lua-Interpreter Folgendes aus:
200?"200px":""+(this.scrollHeight+5)+"px");">
Hallo Welt!
Grundsätzlich ist damit zu rechnen. Im Programm haben wir die Druckfunktion aufgerufen. Die Druckfunktion nimmt eine beliebige Anzahl von Parametern und gibt sie sequentiell auf dem Bildschirm aus. BEI dieses Beispiel Wir haben ihm den String (Zeichenkette) "Hello world!" übergeben. Mit dem gleichen Erfolg können Sie als Parameter übergeben:
200?"200px":""+(this.scrollHeight+5)+"px");">
print(8) – irgendeine Dezimalzahl
-- Ausgabe: 8
Print(0xDEADBEEF) – Hexadezimalzahl
-- Ausgabe: 3735928559
Print("0xDEADBEEF") -- und das ist ein String, keine Zahl! Sehen Sie die Zitate?
-- druckt: 0xDEADBEEF
Print(1.35e-4) -- Fließkommazahl (Bruchzahl)
-- Ausgänge 0.000135. 1,35e-4 sollte als "1,35-mal" verstanden werden
- durch zehn hoch minus vierte Potenz", falls jemand es nicht weiß.
Print((198*99)-3*500 + 14/88) – Ausdruck
-- Zeigt den Wert des Ausdrucks an: 18102.159090909. Keine schlechte Alternative
-- ein Tischrechner!
Print(198/7, "fertilizer", 2^9) -- einige willkürliche Parameter
-- Typ. Die Werte von jedem von ihnen werden angezeigt, getrennt durch Zeichen.
-- Registerkarten:
-- 28.285714285714 Dünger 512
-- Beachten Sie, dass Anführungszeichen um Dünger herum nicht gedruckt werden!
Print(1.35) -- zwei Zahlen, nicht dezimal 1.35!
-- Ein Komma wird verwendet, um Optionen zu trennen.
-- Ausgänge:
-- 1 35
Das „--“-Zeichen ist nicht nur eine Nachahmung eines Bindestrichs, der der Schönheit wegen eingefügt wird. Das „--“-Zeichen in Lua kennzeichnet Kommentare: Hinweise für den Programmierer, die vom Interpreter ignoriert werden und den Code verständlicher machen sollen. Sie können versuchen, in das Programm zu schreiben:
200?"200px":""+(this.scrollHeight+5)+"px");">
--print("nichts")
Der Interpreter wird denken, dass es sich um einen Kommentar handelt, und die Anweisung nicht ausführen.
Hinweis an die Gastgeberin: Wenn Sie nur eine Zeile drucken möchten, können Sie den Druckaufruf so schreiben, ohne Klammern:
200?"200px":""+(this.scrollHeight+5)+"px");">
print "Nur eine Zeichenfolge"
Komfort ist sicherlich fraglich: Denken Sie nur daran, dass dies möglich ist. Solche Aufrufe sind jedoch nicht erlaubt:
200?"200px":""+(this.scrollHeight+5)+"px");">
print 2 funktioniert nicht, 2 ist kein String.
print 2*2 + 6 -- mehr geht nicht
Str = "Zeichenfolge!!" -- setze die Variable str auf "string!!"
-- lesen Sie weiter unten über Variablen
print str - funktioniert auch nicht.
In jedem der oben genannten Fälle verweigert das Programm einfach die Arbeit. Bei einem Aufruf ohne Klammern darf also nur ein String-Literal (also eine in Anführungszeichen eingeschlossene Zeichenfolge) auf den Namen der Funktion folgen, sonst nichts. In Zukunft werde ich etwas ausführlicher auf diese Funktion eingehen, aber fürs Erste reicht es Ihnen.
In jeder guten Programmiersprache ist es möglich, Variablen zu deklarieren: kleine Container, die irgendeine Art von Daten enthalten können. Bei Lua geht das so:
200?"200px":""+(this.scrollHeight+5)+"px");">
<имя_переменной> = <выражение>
Zum Beispiel:
200?"200px":""+(this.scrollHeight+5)+"px");">
star = 8 -- Die star-Variable speichert jetzt die Zahl 8
wars = "owl" -- In der wars-Variablen die Zeichenfolge "owl"
jedi = 42/2 -- Die Variable jedi ist die Zahl 21
luke = star*jedi – Variable luke ist die Zahl 168 (ja, 21 mal 8)
Die Werte von Variablen und Ausdrücken mit ihnen können auch auf dem Bildschirm angezeigt werden:
200?"200px":""+(this.scrollHeight+5)+"px");">
Druck (Stern, Kriege, Jedi, Jedi-Star+Luke)
-- Ausgänge:
-- 8 Eulen 21 181
Versuchen Sie nur nicht, die Variablen Stern und Kriege hinzuzufügen - der Versuch, 8 zu "Eule" hinzuzufügen, wird Ihnen nichts nützen!
Wie Sie bemerkt haben sollten, kann der Name einer Variablen fast alles sein: Hauptsache, er beginnt nicht mit einer Zahl. Im Ernst, Sie können sogar eine Variable namens print deklarieren und dann funktioniert die print-Funktion nicht mehr, da der Name print auf die neu deklarierte Variable verweist. Aber es gibt eine Gruppe von Wörtern, die nicht als Variablennamen verwendet werden dürfen - das sind Sprachschlüsselwörter, die wir noch nicht getroffen haben, die aber definitiv einen Blick wert sind:
200?"200px":""+(this.scrollHeight+5)+"px");">
und brechen sonst tun, wenn Ende
false für Funktion goto if in
local nil not oder repeat return
dann wahr bis während
Wenn Sie eine Variable mit einem dieser Namen erstellen, verursachen Sie einen Fehler im Programm, und es wird definitiv nicht funktionieren. Beachten Sie, dass es in Lua 5.1 kein goto-Schlüsselwort gibt, und Sie können eine Variable so nennen, aber Sie sollten das besser nicht tun.
Beachten Sie auch, dass bei Variablennamen zwischen Groß- und Kleinschreibung unterschieden wird. Das bedeutet, dass foo, fOo, fOO und FOO vier verschiedene Variablen sind. Wenn Sie also einen Variablennamen klein und später groß schreiben, wird das Programm höchstwahrscheinlich nicht richtig funktionieren.
Und jetzt ein wichtiger Punkt: Was passiert, wenn Sie versehentlich oder absichtlich auf eine nicht vorhandene Variable verweisen? In den meisten anderen Sprachen wird dies einen Fehler auslösen, aber in Lua ist diese Situation akzeptabel. Sie wird so behandelt, als ob eine nicht existierende Variable tatsächlich existiert, aber ihr Wert existiert Null. Null- merken Sie sich dieses Wort! ist eine spezielle Art von Wert in Lua, die "nichts" bedeutet. Nicht Null und kein leerer String (ein String wie "" - versuchen Sie, ihn auf dem Bildschirm anzuzeigen), sondern einfach nichts. Vergleichen Sie dies mit diesem Modell: Es gibt zwei Personen, die eine hat ein Bankkonto, aber kein Geld, und die andere hat überhaupt kein Bankkonto. In Bezug auf Lua wird davon ausgegangen, dass das Konto des Ersten 0 Dollar und das Konto des Zweiten 0 Dollar hat Null. Und nicht einmal Dollar, sondern einfach Null. Ich hoffe, ich habe dich nicht verwirrt.
Versuchen Sie beispielsweise, das folgende Programm auszuführen:
200?"200px":""+(this.scrollHeight+5)+"px");">
-- main.lua --
foo="bar"
drucken (foo, baz)
-- Ausgänge:
- Balken Null
Somit hat die Variable baz, die nicht existiert, aber als existierend angenommen wird, den Wert nil, und die Druckfunktion versteht dies und gibt ihn als Zeichenfolge "nil" auf dem Bildschirm aus. Lua hat eine nette Methode, um die Existenz einer Variablen zu prüfen: Wenn der Wert einer Variablen nicht null ist, dann ist sie zumindest deklariert. Andererseits können Sie eine Variable explizit gleich null deklarieren:
200?"200px":""+(this.scrollHeight+5)+"px");">
cool_var = null
Dies ist möglich, und obwohl es auf den ersten Blick albern erscheint, wird dies manchmal getan. In den folgenden Lektionen erfahren Sie, wer und warum, und Sie werden wahrscheinlich dasselbe tun. Manchmal natürlich.
Seien Sie vorsichtig mit nil ": Sie können nil drucken, aber Sie können damit nicht rechnen! Das heißt, wenn print (nil) mit Ihnen durchkommt, führt eine Konstruktion wie 99 + nil zu einem Fehler, selbst wenn Sie es tun würden wie 99+ null war 99. Glauben Sie mir, ich war auch verärgert, als ich es herausfand.
Zusammenfassung:
1. Wir haben die Druckfunktion kennengelernt, was sie kann und wie man sie ohne Klammern richtig aufruft.
2. Wir haben gelernt, wie man Variablen deklariert, wie man Ausdrücke auswertet (wenn auch ziemlich viel), welche Namen Variablen haben können.
3. Wir haben von der Null erfahren, die von ihrem mystischen Geheimnis durchdrungen ist, und haben Vertrauen gewonnen, dass wir in Zukunft mit ihr verbunden sein werden.
Für Neugierige, die ihr Wissen vertiefen wollen, biete ich einfache Übungen an, die weggelassen werden können, wenn Sie sich bereits kompetent genug fühlen:
1. Schreiben Sie ein Programm, das den Refrain Ihres Lieblingsliedes ausdruckt.
2. Versuchen Sie, die Werte der folgenden Ausdrücke anzuzeigen. Versuchen Sie zu verstehen, warum einige von ihnen funktionieren und andere nicht. Sehen Sie, welche Fehler durch fehlerhafte Ausdrücke verursacht werden.
200?"200px":""+(this.scrollHeight+5)+"px");">
2 + "Zeichenkette";
6 + "14";
"box" - "vox";
1 * "11b"
"148" * "1e6";
3. Schreiben Sie ein Programm, das zwei vertauscht Variablenwerte. Also:
200?"200px":""+(this.scrollHeight+5)+"px");">
a = 6502
b=8086
Machen Sie a gleich 8086 und b gleich 6502. Erstellen Sie dazu eine dritte Variable und führen Sie einfache Permutationen durch. Stellen Sie sicher, dass das Problem korrekt gelöst ist, indem Sie vor dem Austausch print(a,b) und danach print(a,b) aufrufen.
Hallo alle.
Heute werfen wir einen kurzen Blick auf die Lua-Sprache, einige ihrer Funktionen und die Ausführung unserer Skripte in RakBot.
Lua ist eine Skript-Programmiersprache, die für eine schnelle Datenverarbeitung entwickelt wurde. Mit Hilfe dieser Sprache erstellen viele Entwickler künstliche Intelligenz in Spielen, schreiben Algorithmen zur Levelgenerierung und sie wird auch verwendet, um Ressourcen / Spielmodifikationen in Multi Theft Auto: San Andreas (ähnlich SA: MP) zu entwickeln. Tatsächlich ist dies die einfachste Sprache und mit ihrer Hilfe lernen wir, wie wir unsere eigene Logik für Bots schreiben, die RakBot verwenden wird.
Lassen Sie uns die Grundlagen der Programmierung durchgehen, mit denen wir arbeiten müssen.
beachten Sie : Dieser Artikel wird in Bezug auf die Lua-Sprache gekürzt, da RakBot nur einen kleinen Teil davon verwendet. Viele Lua-Funktionen sind in RakBot einfach nicht verfügbar, daher werde ich mich auf die Version von RakBot konzentrieren.
Es gibt eine Tradition unter allen Autoren von Büchern und Dokumentationen in verschiedenen Sprachen, dass dies das erste Programm ist, das "Hello World" druckt.
Nun, versuchen wir es zu schreiben, aber in RakBot. Wir gehen auf die offizielle RakBot-Website und suchen nach dem Abschnitt „Verfügbare Funktionen“, dem Abschnitt „Ereignisse“.
Wir brauchen eine Veranstaltung onScriptStart(), die automatisch aufgerufen werden, wenn das Skript von RakBot selbst geladen wird.
In dieser Funktion müssen wir die Logik beschreiben, die RakBot „ein „Hello World“ in das Chatprotokoll schreibt. Sehen Sie sich dazu auf derselben Seite in der Dokumentation den Abschnitt „Functions“ an.
Erste Funktion printLog(text)- das brauchen wir. Mit dieser Funktion senden wir eine Nachricht an den Chat von RakBot. Dazu schreiben wir:
Wir haben die Logik in ein Textdokument geschrieben, aber wie sagen wir RakBot, dass er unser Skript ausführen soll? Dazu müssen Sie die Datei mit der Erweiterung speichern .lua
und lege es in einen Ordner Skripte, im RakBot-Ordner.
Ich habe ein Textdokument mit dem Namen " beispiel.lua
". Lassen Sie uns versuchen, RakBot auszuführen und sehen, was wir bekommen.
Wie wir sehen können, findet RakBot beim Starten das Skript " beispiel.lua", und führt es dann aus. Daraus können wir schließen, dass das Skript initialisiert wird, wenn RakBot selbst gestartet wird oder wenn alle Skripte mit dem Befehl neu geladen werden !Skripte neu laden.
Herzlichen Glückwunsch, Sie haben gerade Ihre geschrieben eigenes Skript für RakBot!
Wir haben bereits gelernt, Hello World in der RakBot-Konsole zu schreiben, aber wir wollen komplexe Bots schreiben, die unter bestimmten Bedingungen die ganze Arbeit für uns erledigen.
Fast alles, was beim Programmieren passiert, lässt sich wie folgt beschreiben: Daten nehmen, etwas damit machen, Ergebnis zurückgeben.
In diesem Fall ist RakBot selbst die Daten. Es startet unsere Skripte von selbst und sendet uns auch Daten, die wir nach Belieben verarbeiten können und am Ende das Ergebnis erhalten.
Lassen Sie uns ein einfaches Szenario mit einer Bedingung schreiben. Die Bedingung ist der Spitzname des Bots. Wenn der Spitzname des Bots „CMaster“ ist, dann zeigen wir „CM FOREVER“ im RakBot-Chat an, wenn der Spitzname des Bots völlig anders ist, zeigen wir „Nonamer“ im Chat an.
Dazu können wir den Bedingungsoperator if else verwenden, der auch als Verzweigungsoperator bekannt ist. Es nimmt eine Bedingung an, die entweder true oder false zurückgeben muss. Wenn die Bedingung wahr ist, wird der darin enthaltene Code ausgeführt, wenn er falsch ist, wird er nicht ausgeführt.
Darauf basiert der größte Teil der Logik jeder Anwendung. Wörtlich, wenn mit "IF" übersetzt wird, dann - "MEANS", sonst - "ELSE" Wenn es sehr schwierig ist - keine Sorge, Sie werden alles weiter verstehen.
Lua hat die folgenden Vergleichsoperatoren:
> Mehr
<
Меньше
>= Größer als oder gleich
<=
Меньше или равно
~= Ungleich
== Gleich
Wenn wir schreiben " CMaster" == "CM"- wir haben den Wert False , also falsch
Wenn wir schreiben " CMaster" == "CMaster"- wir haben den Wert True , das heißt wahr.
5 > 10 – falsch 5< 10 -- истина 10 ~= 15 -- истина 10 >= 5 – wahr
Versuchen wir, die Verzweigungslogik in unserem vorherigen Szenario zu verwenden.
Der Code, den wir zuvor geschrieben haben:
Funktion onScriptStart() printLog("Hallo Welt!"); Ende
Wandeln wir es wie folgt um:
Funktion onScriptStart() botName = getNickName() if(botName == "CMaster") then printLog("CM FOREVER"); sonst printLog("Nonamer"); ende ende
Lassen Sie uns diesen Code von oben nach unten aufschlüsseln. Ich rate Ihnen, sofort damit zu beginnen, Code lesen zu lernen. Versuchen wir also zu lesen, was wir bekommen haben
Funktion onScriptStart() - erstellt eine Funktion namens onScriptStart botName = getNickName() - schreibt den Bot-Namen in die botName-Variable if(botName == "CMaster") then - wenn der Bot-Name gleich "CMaster" ist, dann printLog(" CM FÜR IMMER"); - Schreiben Sie an den Chat "CM Forever". else- ELSE, oder wenn der Bot-Name NICHT GLEICH "CMaster" ist printLog("Nonamer"); - Schreiben Sie in den Chat "Nonamer" Ende- Ende der Bedingung Ende- Ende der Funktion
Lassen Sie uns versuchen, den von uns geschriebenen Code zu testen. Ich habe den geänderten Code auf die gleiche Weise unter dem Namen " beispiel.lua "und startete RakBot mit dem Spitznamen " Mason_Bennett".
Nachdem wir unser Skript hochgeladen hatten, chattete RakBot mit Nonamer. Versuchen wir, uns mit dem Spitznamen " CMaster".
Wie wir sehen können, funktioniert unsere Kondition erfolgreich und wir sehen im Chat, was wir wollten.
Lassen Sie uns die Variablen ein wenig durchgehen. Sie haben ein Blatt Papier und möchten es speichern. Speichern Sie auf irgendeine Weise - irgendwo, wo Sie es ablegen können, um es nicht zu verlieren. Wir können zum Beispiel unseren Zettel in das Schließfach legen und bei Bedarf wieder herausnehmen. Wenn wir ein neues Blatt haben und das alte nicht benötigen, werfen wir das alte Blatt weg und legen ein neues ein.
Dies ist die Logik der Variablen. Wir können eine Variable mit den gewünschten Namen erstellen und Werte darauf schreiben, was wir im vorherigen Beispiel mit der botName-Variablen getan haben.
In Lua können wir in eine Variable schreiben, was wir wollen. Zum Beispiel möchte ich eine Variable namens PaperList erstellen und den Text "Lua - Lektion #2" hineinschreiben. Dazu schreibe ich:
PaperList = "Lua - Lektion #1"
Was haben wir hier getan? Ich habe den Namen geschrieben und den Zuweisungsoperator "=" verwendet, und jetzt kann ich diese Variable überall in meinem Skript verwenden.
Ich denke, wenn Sie sich an Mathematik auf dem Niveau von maximal Klasse 5 erinnern, wird hier alles klar sein.
Lua hat mehrere Arten von Variablen, diese sind nil, boolean, number, string . Keine Angst, es ist alles ganz einfach.
Tatsächlich gibt es noch einige mehr, aber ich habe bereits gesagt, dass RakBot die meisten Funktionen fehlen.
nil - kein Wert.
boolean - logische Werte, akzeptiert zwei Varianten von Werten - entweder wahr oder falsch.
Zahl - eine reelle Zahl mit doppelter Genauigkeit. Lua hat keinen ganzzahligen Typ, daher fungiert es sowohl als reeller als auch als ganzzahliger Typ.
Zeichenfolge - eine Zeichenfolge, hier, denke ich, ist alles klar.
Nun, lassen Sie uns versuchen, einige Variablen zu erstellen und mit ihnen "herumzuspielen".
Zahl = 0; - Erstellen Sie eine Variable namens Nummer und weisen Sie ihr den Wert 0 zu
Zahl = Zahl + 5; - Zuweisen eines Wertes zur Variablen Nummer + 5 (also 0 + 5), jetzt haben wir hier die Nummer 5 gespeichert.
Zahl++; - ++ - erhöhen. Mit anderen Worten, Sie nehmen eine Variable und erhöhen sie um eins. Das heißt, (5 + 1) - jetzt haben wir 6 in der Zahlenvariablen.
Nummer --; - -- verringern. Mit anderen Worten, wir verringern um eine Einheit. (6 - 1) - jetzt ist der Wert 5.
string = "Hallo" - erstellt eine String-Variable mit dem Wert "Hallo"
string = string .. "," - String-Verkettung, auch bekannt als String-Addition. Was haben wir hier getan? Geben Sie den Namen der Variablen an, geben Sie den Verkettungsoperator ".." an, und geben Sie dann eine weitere Zeile an, die der ersten hinzugefügt werden soll. Jetzt haben wir den Wert „Hallo“ in der „string“-Variablen.
Zeichenfolge = Zeichenfolge.. getSpitzname() - jetzt haben wir zu "Hallo" den Spitznamen des Bots hinzugefügt, sei es "Michel". Jetzt haben wir den Wert „Hallo, Michel“ in der String-Variablen.
boolesch = wahr ; - Erstellen Sie eine boolesche Variable mit dem Wert true (TRUE).
boolesch = getSpitzname() == "Dimosha" - vergleiche den Bot-Namen mit der Dimosha-Zeichenfolge. Da der Name des Bots, den wir haben, Michel ist, wird aus dem vorherigen Beispiel der Wert false (FALSE) hier geschrieben.
Ein wenig über Funktionen. Es gibt Funktionen, die Werte zurückgeben, und es gibt solche, die keinen Wert zurückgeben. Wie Sie sehen können, unsere Funktion onScriptStart gibt keinen Wert zurück, sondern führt einfach den darin angegebenen Code aus.
Wir können unsere eigenen Funktionen erstellen, um einen Teil der Logik von der Methode zu isolieren und bestimmte Operationen auszuführen.
Funktionen können Werte annehmen oder nicht.
Gehen wir den einfachsten Weg durch: eine Funktion ohne Parameter und ohne Rückgabewert, die 5 + 10 addiert und das Ergebnis an die Konsole des RakBot ausgibt.
Ich erstelle eine Funktion namens Add :
Funktion Add() -- Funktion erstellen Add printLog(5 + 10) -- RakBot-Methode verwenden, um auf Konsole zu drucken end-- Ende der Funktion
Wir haben aus zwei Gründen eine nicht ganz universelle Funktion geschaffen:
- Wenn ich andere Nummern hinzufügen muss, muss ich eine andere mit derselben Funktion erstellen
- Ich kann den empfangenen Wert nicht außerhalb der Funktion verwenden
Versuchen wir, den ersten Fehler zu beheben. Dazu fügen wir der Funktion zwei Parameter hinzu, die die Zahlen für die Addition übernehmen. Wir werden es auf folgende Weise tun:
Funktion Add(a, b) printLog(5 + 10) end
Jetzt haben wir zwei Werte in der Methode verfügbar, die in zwei neuen Variablen a und b enthalten sind, aber ich bekomme auf der Konsole immer noch 15. Lass uns das beheben:
Funktion Add(a, b) printLog(a + b) end
Perfekt. Beim Aufruf dieser Methode erhalten wir nun das Ergebnis der Addition in der Konsole. Lassen Sie uns versuchen zu testen. Ändern wir unseren Code in beispiel.lua zum nächsten:
Funktion Add(a, b) printLog(a + b) end function onScriptStart() Add(5, 10); Hinzufügen (123, 4324); Hinzufügen (555, 111); Ende
Und lassen Sie uns versuchen, RakBot auszuführen. Mal sehen, was daraus wird:
Dies löste unser erstes Problem. Versuchen wir, die zweite zu lösen, damit unsere Funktion das Ergebnis zurückgibt.
Lassen Sie uns die Add-Funktion umschreiben:
Funktion Add(a, b) gibt a + b end zurück
return ist ein Schlüsselwort zum Zurückgeben eines Werts von einer Funktion. Lassen Sie uns jetzt die Methode onScriptStart umschreiben:
Funktion onScriptStart() printLog("Erster Wert: "..Add(5, 10)); printLog("Zweiter Wert: "..Add(123, 4324)); printLog("Dritter Wert: "..Add(555, 111)); Ende
Lass uns nachsehen, was passiert ist.
Wir könnten drei Variablen erstellen, indem wir ihnen Werte aus Funktionen zuweisen Hinzufügen und dann an die Methode übergeben Druckprotokoll, aber ich habe es nicht getan, weil der Code besser lesbar und schöner aussieht.
Jetzt haben wir gelernt, wie wir unsere eigenen Funktionen mit Parametern ohne Parameter erstellen und Werte von ihnen zurückgeben. Ich glaube, dass Ihnen diese Grundlagen ausreichen werden, um Ihren eigenen Bot in RakBot "a zu schreiben. In den folgenden Lektionen werden wir den einfachsten Bot erstellen, den wir nach und nach verkomplizieren werden, indem wir immer mehr neue Features und Funktionen hinzufügen.
