Funktionen sind Blöcke von Code, die Sie mehrfach auf Befehl ausführen können.Du kannst sie auch mit Ereignissen verbinden oder ihnen als Callbacks zuweisen.
Grundfunktionen
Eine Funktionsdefinition umfasst:
- Der Umfang der Funktion (global oder local).
- Das function-Schlüsselwort.
- Der Name der Funktion in camelCase.
- Die Parameter der Funktion in Klammern ( () ).
- Der Codesoder "Körper" der Funktion.
- Das end-Schlüsselwort.
Der Körper der Funktion wird ausgeführt, wenn Sie die Funktion aufrufen.Um eine Funktion aufzurufen, gib ihren Namen und geschweifte Klammern ein.Du kannst eine Variable definieren, die den Rückgabewert akzeptiert oder den Rückgabewert anstelle einer Variable verwendet.
-- Diese Funktion hat keine Parameter und gibt nil zurück
local function addOneAndTwo()
local result = 1 + 2
print(result)
end
-- Eine Funktion ohne zurückgebenaufrufen
addOneAndTwo() -- 3
Parameter
Parameter sind Variablen, die du der Funktion zur Verfügung stellst und nur im Umfang der Funktion verwendet werden.Funktionen haben standardmäßig keine Parameter.Wenn du eine Funktion mit mehr Parametern aufrufst, als sie erwartet, ignoriert Luau die zusätzlichen Parameter.Wenn du eine Funktion mit weniger Parametern aufrufst, als sie erwartet, gibt Luau nil für alle fehlenden Parameter durch.
-- Diese Funktion hat zwei Parameter: num1 und num2
local function addNumbers(num1, num2)
print(num1 + num2)
end
addNumbers(2, 3) -- 5
addNumbers(5, 6, 7) -- 11
addNumbers(9) -- attempt to perform arithmetic (add) on number and nil
Zurück
Im Körper der Funktion gibt das Schlüsselwort return ein Ergebnis aus einer Berechnung zurück.Du kannst mehrere Werte aus einer Funktion zurückgeben. return beendet die Funktionsausführung, und Luau erwartet, dass das Schlüsselwort end den Anweisungen return folgt, also schreibt der Code zwischen dem return Befehl und dem end Befehl einen Fehler.
-- Diese Funktion gibt einen Rückgabewert zurück
local function addNumbers(num1, num2)
local result = num1 + num2
return result
end
print(addNumbers(1, 2)) -- 3
local seven = addNumbers(3, 4)
print(seven) -- 7
-- Diese Funktion gibt mehrere Werte zurück: Summe und Differenz
local function addAndSubtract(num1, num2)
local sum = num1 + num2
local difference = num1 - num2
return sum, difference
end
-- Eine Funktion aufrufen und mehrere Rückgabewerte erwarten
local sum, difference = addAndSubtract(2, 3)
print(sum) -- 5
print(difference) -- -1
Methoden
Methoden sind Funktionen, die Mitglieder eines Objekts sind, wie eine Klasse oder Tabelle.Sie erwarten das Objekt selbst ( self ) als erstes Argument.Wenn du eine Methode aufrufst, verwende die Kolonnennotation ( : ) statt der Punktnotation ( . ), um self als erstes Argument automatisch durchzugeben.
Alle Objekte in Roblox stammen von Instance und haben gemeinsam verwendete Methoden, einschließlich Instance:Destroy(), Instance:Clone() und Instance:FindFirstChild().
Die Aussage table:Method() ist funktional identisch mit table.Method(table) und wenn eine Methode definiert wird, ist function table:Method() identisch mit function table.Method(self) .Dieses Verhalten erstreckt sich auf Instance Methoden, da sie auch aus Tabellen abgeleitet werden.
Definieren von Methoden
Um eine Methode in einer Tabelle zu erstellen, verwende den Namen der Methode als Schlüssel und die Methode als Wert.In der Definition der Methode bezieht sich der self -Parameter auf die Eltern-Tabelle der Methode.Wenn du eine Methode mit der Kolonnennotation aufrufst, übermittelst du den Tisch selbst als erstes Argument.Du kannst Parameter für eine Methode definieren, aber du musst sie nach dem self -Parameter auflisten.
Im folgenden Beispiel hat die testButton Tabelle eine Methode als Wert der changeEnabled Schlüssel.Du kannst überprüfen, dass self sich auf die Eltern-Tabelle der Methode bezieht, indem du den Wert von self.enabled druckst.
local testButton = {
enabled = true,
changeEnabled = function(self, isEnabled)
self.enabled = isEnabled
print(self.enabled)
end
}
print(testButton.enabled) -- wahr
-- Rufe die Methode auf
testButton:changeEnabled(false) -- false
Rückrufe
Callbacks sind Funktionen, die als Reaktion auf eine andere Funktion oder Prozess ausgeführt werden.
Grundrufe
Funktionen können an andere Funktionen übergeben werden, zum Beispiel kann eine anonyme Funktion verwendet werden, um einen Rückruf zu implementieren, der dann verwendet wird, um eine Liste von von zu sortieren .
local Players = game:GetService("Players")
local sortedPlayers = Players:GetPlayers()
table.sort(sortedPlayers, function(a, b)
-- Verwende einen anonymen Rückruf, um Spieler nach Namen zu sortieren
return a.Name < b.Name
end)
Im Roblox-API beziehen sich Rückrufe auf ein Mitglied einer nur lesenden Funktion, Rückrufe werden bis zur zurückgebenerzeugt. Weit verbreitete Rückrufe umfassen:
- MarketplaceService.ProcessReceipt , die den kauf von entwicklerprodukten verwaltet.
- BindableFunction.OnInvoke , die die funktion aufruft, wenn ein skript BindableFunction:Invoke(...) aufruft.
- RemoteFunction.OnClientInvoke, die die funktion aufruft, wenn der server RemoteFunction:FireClient(player, ...) oder RemoteFunction:FireAllClients(...) aufruft.
- RemoteFunction.OnServerInvoke , die die funktion aufruft, wenn ein client RemoteFunction:InvokeServer(...) anruft.
Um einen Callbackzu setzen, weise einer Funktion eine zuzuordnen.Zum Beispiel ist BindableFunction.OnInvoke ein Rückruf von BindableFunction.Du kannst eine benannte oder anonyme Funktion darauf einstellen, und du kannst diese Funktion aufrufen ( aufrufen ), indem du die Methode auf dem Callbackaufrufst.Die Argumente, die du an :Invoke() weitergibst, an den Callback, und der Rückgabewert der Rückruffunktion kehrt zum Anrufer von :Invoke() zurück.
local bindableFunction = Instance.new("BindableFunction")
bindableFunction.OnInvoke = function(number)
return 2 * number
end
print(bindableFunction:Invoke(42)) -- 84
Funktionstechniken
Ereignishändler
Du kannst eine Funktion zuweisen, die als Ereignishändler bekannt ist, die ausgeführt wird, wenn ein Ereignis ausgelöst wird.Zum Beispiel können Sie eine Funktion namens onPlayerAdded() zum Players.PlayerAdded-Ereignis erstellen, um den Namen jedes Spielers anzuzeigen, der beitritt.Für weitere Informationen, siehe Veranstaltungen.
local Players = game:GetService("Players")
local function onPlayerAdded(player)
print(player.Name .. " joined the game!")
end
Players.PlayerAdded:Connect(onPlayerAdded)
Anonyme Funktionen
Du kannst Funktionen ohne Namen erstellen, die als anonyme Funktionen bekannt sind, um als Callbacks und Ereignishändler verwendet zu werden.Wie bei benannten Funktionen müssen anonyme Funktionen mit den Schlüsselwörtern function und end beginnen und enden, aber du brauchst das Schlüsselwort local nicht, um den lokalen Umfang anzugeben, weil sie immer einen lokalen Umfang haben.
Im folgenden Beispiel sind der Rückruf für die task.delay()-Funktion und der Event-Handler für das Players.PlayerAdded-Ereignis beide anonyme Funktionen.
-- Anonyme Funktion in einem Rückruf bei task.delay()
task.delay(2, function(exactTimeElapsed)
print(exactTimeElapsed) -- 2.0064592329945
end)
-- Anonyme Funktion in einem Event-Handler
local Players = game:GetService("Players")
Players.PlayerAdded:Connect(function(player)
print(player.Name .. " joined the game!")
end)
Funktionen in Modulskripten
Du kannst Funktionen über mehrere Skripte wiederverwenden, indem du sie in ModuleScripts speicherst.Funktionen sind ein eingeben, sodass du sie in Tabellen mit anderen Daten speichern kannst.
Variadische Funktionen
Eine variadische Funktion akzeptiert eine beliebige Anzahl von Argumenten. Zum Beispiel ist Globals.LuaGlobals.print() eine variadische Funktion.
Definieren von variativen Funktionen
Um eine variablen Funktion zu definieren, verwendest du das -Token als letztes oder einziges Argument (nicht mit > zu verwechseln, dem Konjunktionsoperator ).Du kannst die ... Werte in einer Tabelle für einfache Bedienung platzieren.
Das variadische Token ... kann nur innerhalb von Funktionen verwendet werden, die als variadisch definiert sind; Funktionen oder Rückrufe, die innerhalb einer variadischen Funktion definiert sind können nicht die gleiche ... verwenden, auch wenn sie selbst variadisch sind.
... verhält sich nicht wie eine normale variable und kann nur an andere funktionen übergeben, zurückgegeben oder in eine tabelle gesetzt werden.
local function variadic(named, ...)
local arguments = {...} -- verpacke die zusätzlichen argumente in eine tabelle
print("Named argument =", named)
for i, value in arguments do
print("Input No.", i, "=", value)
end
end
variadic(10, "Hi", 20, "Variadic Function")
--[[ Ausgabe:
Named argument = 10
Input No. 1 = Hi
Input No. 2 = 20
Input No. 3 = Variadic Function
]]
Vorwärtsargumente
Du kannst variadische Funktionen als Wrapper um andere Funktionen definieren, um Argumente vom Wrapper zu den anderen Funktionen zu Passoder weiterzuleiten.
local function printAround(functionToPrintAround, ...)
print("Before")
functionToPrintAround(...)
print("After")
end
local function addNumbers(x, y, z)
print("x =", x)
print("y + z =", y + z)
end
printAround(addNumbers, 1, 2, 3)
--[[ Ausgabe:
Before
x = 1
y + z = 5
After
]]
Rufe eine variadische Funktion mit Arrays auf
Wenn du einen tabellierten Arrays von Werten an eine globale variadische Funktion übergeben möchtest, wie z. B. print(), kannst du die globale unpack() Funktion verwenden, um die Werte der Tabelle anstelle der Tabelle selbst zu übergeben.