Die Funktionen werden die meiste Zeit in Klammern und mit einer Liste von Argumenten geschrieben, mit denen dieselben eine bestimmte Aktion ausführen können. Dabei ist festzustellen, dass für diese Funktionen keine Argumente erforderlich sind. Die Klammern müssen jedoch angegeben werden (siehe Funktionsbeispiel) Was wir in Lua als Ausdrücke verwenden:
Wie wir sehen, könnten wir Funktionen beider beschriebener Formen verwenden, aber es gibt einen Sonderfall, in dem die Funktion ein einziges Argument hat und dieses Argument eine Literalzeichenfolge oder ein Konstruktor für eine Tabelle oder ein Array ist. In diesem Fall sind die Klammern optional.
print "Hallo Welt" <-> print ("Hallo Welt") Datei 'file.lua' <-> Datei ('file.lua') print [[mehrzeiliges Array msj]] <-> print ([[mehrzeiliges Array msj]]) f {var1 = 17, var2 = 30} <-> f ({var1 = 17, var2 = 30}) Typ {} <-> Typ ({})
Nach dem Beispiel konnten wir die Funktionen beider Formen schreiben, die gleichermaßen gültig sind.
Funktionen definieren
Ein Programm in Lua kann sowohl in C als auch in der Sprache selbst definierte Funktionen verwenden. Beispielsweise sind alle Standardfunktionen in der Lua- Bibliothek in C geschrieben , was für Entwickler nicht relevant ist, da der Aufruf von beiden nicht der Fall ist hat einen Unterschied.
Da sich die Definition nicht von anderen Sprachen unterscheidet, wird die herkömmliche Syntax einer Funktion durch den Namen der Funktion, eine Liste von Parametern und den Hauptteil der Funktion bestimmt. Dies ist eine Liste von Anweisungen. Schauen wir uns ein Beispiel an, um zu veranschaulichen, was passiert erklärt:
Funktionsoperation (var) lokale Summe = 0 sum = var + 6 Rückgabesumme ende
Wir haben unsere Funktion bereits, diese Methode hat jedoch keinen großen Nutzen, da sie aufgerufen werden muss, indem der benötigte Parameter gesendet wird. Dazu können wir unserem Code eine weitere Zeile hinzufügen, um ihn aufzurufen:
Funktionsoperation (var) lokale Summe = 0 sum = var + 6 Rückgabesumme ende drucken (Vorgang (57))
Wenn wir unser Beispiel in unserem Terminal ausführen, können wir sehen, wie unser Programm den Parameter empfängt und gemäß den in unserer Funktion definierten Operationen einen Wert zurückgibt:
Was wir an den Funktionen in Lua hervorheben können, ist, dass die Parameter als lokale Variablen fungieren, da sie mit den Werten initialisiert werden, die sie beim Aufruf der Funktion erhalten. Darüber hinaus können wir eine Funktion mit einer anderen Anzahl von Argumenten aufrufen, die in der Funktion definiert sind. Lua passt sich dem so an, wie dies bei Mehrfachzuweisungen der Fall ist. Dieses Thema haben wir im letzten Tutorial behandelt , in dem die zusätzlichen Argumente und die Parameter verworfen werden Extras erhalten den Werttyp Null. Stellen wir uns zum Beispiel vor, dass wir die folgende Funktion haben:
function function_multiple (a, b) gibt ein oder b end zurück
Mal sehen, wie wir im nächsten Code die Funktion mit verschiedenen Parametern aufrufen und auf der rechten Seite, wie die Zuordnung erfolgt:
f (8) a = 8, b = null f (8, 15) - a = 8, b = 15 f (8, 15, 4) <-> a = 8, b = 15 (Der Wert 4 wird verworfen)
Obwohl dieses Verhalten zu Programmierfehlern führen kann, ist es insbesondere für Standardargumente auch nützlich.
Mehrere Ergebnisse
Eine unkonventionelle, aber durchaus nützliche Funktion von Lua ist die Möglichkeit, mehrere Ergebnisse zurückzugeben, selbst vordefinierte Sprachfunktionen können dies tun. Ein Beispiel hierfür ist die Funktion string.find , die nach einem Muster sucht , das in einem bestimmten String vorkommt. Diese Funktion gibt zwei Indizes zurück. Der erste ist der Index, an dem dieses Muster beginnt, und der zweite ist der Index, an dem es endet. Sehen wir uns ein praktisches Beispiel für an Verwendung dieser Funktion, die wir in unserer interaktiven Konsole perfekt machen können:
Die Funktionen, die wir in Lua schreiben, können auch mehrere Ergebnisse zurückgeben . Dazu müssen wir sie erst nach unserer Rückkehr auflisten. Sehen wir uns ein Beispiel an, in dem wir eine Funktion erstellen, um den größten Teil einer Liste von Elementen in einem Array und seine Position darin zu lokalisieren:
Funktionsmaximalwert (a) lokales Minimum = 1 lokales m = a [Minimum] für i, val in ipairs (a) do wenn val> m dann Minimum = i; m = val ende ende return m, Minimum ende print (Maximalwert ({8,10,23,12,5}))
Wie wir sehen, ist unsere Funktion recht einfach und in unserer Rückgabe geben wir zwei Werte zurück. In diesem Fall sollten wir gemäß dem, was wir senden, 23 als eine größere Zahl und 3 als die Position zurückgeben.
Variable Anzahl von Argumenten
Zusätzlich zur Funktionalität, mehrere Ergebnisse zurückzugeben, kann Lua auch eine variable Anzahl von Argumenten erhalten , zum Beispiel in den Tutorials, in denen wir die Druckfunktion mit einem, zwei oder sogar drei Argumenten verwendet haben, dh, es kann eine Zahl erhalten Variable von Argumenten, aber genauso wie es das tut, können auch die Funktionen, die wir in Lua entwickeln , ein Beispiel dafür sehen:
funktion funktionsbeispiel (...) lokales s = 0 für i, v in ipairs {...} tun s = s + v ende return s ende print (Funktionsbeispiel (8, 19, 30, 14, 10))
Wenn wir Beobachter bei der Definition unserer Funktion sind, haben wir drei Punkte (…) in den Klammern, was bedeutet, dass unsere Funktion eine variable Anzahl von Argumenten akzeptiert. Wenn die Funktion aufgerufen wird, werden alle gesendeten Argumente intern gesammelt und dann mit verarbeitet In der Funktion ipairs sehen wir uns die Ausgabe unserer Funktion an, die für das Hinzufügen aller Argumente verantwortlich ist, die an sie gesendet wurden:
Da wir sehen, dass diese Funktion von Lua sehr nützlich ist, weil sie es uns ermöglicht, unsere Funktion zu definieren, ohne zu wissen, wie viele Argumente wir an sie übergeben werden, können wir sogar sagen, dass diese Funktionalität ein wenig mit den vorbereiteten Anweisungen vergleichbar ist Operationen mit Datenbanken in Sprachen wie PHP oder Java zu behandeln .
Argumente benennen
Das Senden von Argumenten in Lua ist positionsabhängig, dh, wenn wir eine Funktion aufrufen, entsprechen diese Argumente den Parametern entsprechend ihrer Position, das erste Argument entspricht dem ersten Parameter usw. Manchmal würde es jedoch nicht schaden, die Argumente anzugeben beim Namen.
Diese Funktionalität ähnelt den variablen Argumenten, jedoch ist die Verwaltung bei der Definition der Namen für unsere Argumente viel einfacher, wenn wir nur eine Tabelle oder Anordnung verwenden, was für unsere Funktion sehr nützlich ist Verwenden Sie einige dieser Parameter optional. Sehen wir uns den folgenden Aufruf einer Funktion an, die eine bestimmte Anzahl von Parametern zum Erstellen eines Fensters empfängt:
create_window {x = 0, y = 0, width = 0, high = 200, title = 'Window Lua', background = "blue", Kanten = wahr }
Auf diese Weise hat die Funktion create_window die Freiheit, diese Argumente auf Wunsch namentlich zu überprüfen. Sehen Sie, wie wir diese Argumente in unserer Funktion erhalten und was wir damit tun können:
Funktion create_window (Optionen) - Überprüfen Sie die obligatorischen Optionen if type (options.title) ~ = "string" dann Fehler ("ohne Titel") elseif type (options.ancho) ~ = "number" dann Fehler ("ohne Breitenmaß") elseif type (options.altura) ~ = "number" dann Fehler ("ohne Höhenmessung") ende - Wir wenden die Optionen an create_window (options.title, options.x oder 0, options.and oder 0, Optionen. Breite. Optionen. Höhe. options.fondo oder "white", options.borders ) Ende
Wie wir sehen, sind die Möglichkeiten in unseren Programmen mit dieser Funktionalität viel größer, und obwohl dieses Beispiel illustrativ ist, können wir sehen, wie wir die Argumente mit Namen in unseren Funktionen anwenden können.
Dies ist das Ende dieses Tutorials, in dem wir gelernt haben, wie man mit den Funktionen in Lua umgeht , angefangen von der konventionellen Syntax in anderen Sprachen bis hin zu den Merkmalen der Sprache wie mehreren Ergebnissen, variablen Argumenten und der Möglichkeit, die von uns gesendeten Argumente zu benennen zu unseren Funktionen. Auf diese Weise können wir unseren Programmen viel mehr Leistung hinzufügen, um diese Art von Funktionen einzubeziehen, und die Einfachheit beibehalten, an die Lua uns gewöhnt hat.
