Die Planung von Code ist in vielen Situationen nützlich, z. B. die Sicherstellung, dass Code nach einer bestimmten Aktion oder einem Zyklus abläuft, oder die Verzögerung von Code für eine bestimmte Zeitdauer.Du kannst die task Bibliothek verwenden, um den Roblox-Aufgabenplaner zu optimieren, um Codeszu verwalten und zu planen.Du kannst auch eine ähnliche Bibliothek namens coroutine verwenden, um Code mit zusätzlicher Funktionalität zu planen.
Gewöhnliche Methoden
Die folgenden sind die häufigsten task Methoden, die zum Planen von Codesverwendet werden.Du solltest die Aufgabenmethoden über veraltete Scheduling-Methoden verwenden, wie wait(), um sicherzustellen, dass dein Code optimal ausgeführt wird.
Bestimmte veraltete globale Methoden, wie ( spawn() , delay() und wait() ) können ähnliche Ergebnisse der Codeplanung liefern, sind aber weniger optimiert und konfigurierbar als ihre Alternativen von task.Wenn deine Erfahrung diese veralteten Methoden verwendet, solltest du stattdessen task verwenden, um sicherzustellen, dass der Code deiner Erlebniseffizient und aktuell bleibt.
Die folgende Tabelle listet die relevanten veralteten globalen Methoden und ihre bevorzugten, optimierten Pendants auf:
| Legacy- globale Methoden | Aufgabenmethoden | Zusätzliche Alternativen | | :-------------------------------------- | :------------------------------------------------- | :------------------------------------------------- | | wait() | task.wait() | RunService.Heartbeat | | wait(n) | Library.task.wait()\|task.wait(n) | | | spawn(f) | Library.task.defer()\|task.defer(f) | Library.task.delay()\|task.delay(0, f) | | delay(n, f) | Library.task.delay()\|task.delay(n, f) | | | spawn(function() f(uv1, ...) end) | Library.task.defer()\|task.defer(f, uv1, ...) | Library.task.delay()\|task.delay(0, f, uv1, ...) | | delay(n, function() f(uv1, ...) end) | Library.task.delay()\|task.delay(n, f, uv1, ...) |
task.spawn
task.spawn() nimmt einen Thread oder eine Funktion und setzt sie unmittelbar durch den Aufgabenplanerder Engine fort.Zusätzliche Argumente werden an den Thread oder die Funktion weitergegeben, die wieder aufgenommen wird.
Das folgende Codebeispiel ist ein Beispiel dafür, wie Sie task.spawn() verwenden können, wenn Sie eine Funktion aufrufen, die während der Iteration über eine Reihe von Objekten erzeugen kann:
local function playerAdded(player)
...
(yield)
end
for _, player in Players:GetPlayers() do
task.spawn(playerAdded, player)
end
task.defer
task.defer() nimmt einen Thread oder eine Funktion und verschiebt sie bis zum nächsten Wiederaufnahmezyklus, bei dem sie mit dem Aufgabenplanerdes Engines wieder aufgenommen wird.Zusätzliche Argumente werden an den Thread oder die Funktion zur Wiederaufnahme übergeben.
Sie sollten dies normalerweise verwenden, wenn Sie ein ähnliches Verhalten wie task.spawn() wünschen, aber sich nicht um den Thread kümmern, der sofort ausgeführt wird.Das folgende Codebeispiel zeigt, wie die Aussage print() für "A" verschoben wird, bis die Aussage print() für "B" ausgeführt wird:
task.defer() ist eine optimierte version von spawn(), die einen thread so schnell wie möglich wieder aufnimmt (aber nicht sofort), ohne irgendeine beschleunigung.
task.延迟
task.delay() nimmt einen Thread oder eine Funktion und plant sie für die Wiederaufnahme nach der angegebenen Zeit auf der nächsten Heartbeat Schritt.Der Thread wird mit eingebauter Fehlerbehandlung und Unterstützung für andere Engine-Funktionen fortgesetzt.Alle zusätzlichen Argumente werden an den Thread oder die Funktion zur Wiederaufnahme übergeben.
Da die tatsächliche Verzögerungszeit variieren kann, zeigt das folgende Codebeispiel, wie Sie sie berechnen können, indem Sie die aktuelle Zeit als Argument übergeben:
task.delay(2, function(scheduledTime)
print(os.clock() - scheduledTime) --> 2.038702
end, os.clock())
Eine Dauer von Null wird dazu führen, dass der Thread oder die Funktion auf dem nächsten Schritt fortgesetzt wird.
task.delay() ist eine optimierte version von delay(), die einen thread so plant, dass er nach einiger zeit ohne beschränkung fortgesetzt wird.
task.warten
task.wait() gibt den aktuellen thread bis zur angegebenen dauer (in sekunden) frei und beginnt dann den thread auf dem nächsten Heartbeat schritt wieder.
Die tatsächliche Ausgabezeit kann variieren. Das folgende Codebeispiel zeigt, wie diese Methode es für den Komfort zurückgibt:
Da die tatsächliche Verzögerungszeit variieren kann, zeigt das folgende Codebeispiel, wie Sie die tatsächliche Zeit erhalten können, indem Sie den Rückgabewert der Methode speichern:
Wenn keine Dauer angegeben wird, wird die Dauer auf Null zurückgesetzt, was bedeutet, dass der Thread automatisch auf dem nächsten Schritt fortgesetzt wird.Das bedeutet, dass task.wait() im Verhalten gleichwertig ist mit RunService.Heartbeat.
task.wait() ist eine optimierte version von wait(), die den aktuellen thread nach einiger zeit ohne auslastung fortsetzt, ohne dass es zu verzögerungen kommt.