Programmer le code

Le code de planification est utile dans de nombreuses situations, telles que l'assurance du code d'exécution après l'achèvement d'une action ou d'un cycle spécifique, ou le retardement du code pour une durée spécifique.Vous pouvez utiliser la bibliothèque task pour optimiser le planificateur de tâches de Roblox pour gérer et programmer le code.Vous pouvez également utiliser une bibliothèque similaire appelée coroutine pour programmer du code avec une fonctionnalité supplémentaire.

Méthodes communes

Les suivants sont les méthodes les plus courantes task utilisées pour programmer du code.Vous devez utiliser les méthodes de tâche sur les méthodes de planification héritées, telles que wait(), pour vous assurer que votre code s'exécute de manière optimale.

La table suivante liste les méthodes globales héritées pertinentes et leurs homologues préférés et plus optimisés :

| Méthodes globales héritées | Méthodes de tâche | Alternatives supplémentaires | | :-------------------------------------- | :------------------------------------------------- | :------------------------------------------------- | | 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, ...) |

tâche.régénération, apparition

task.spawn() prend un thread ou une fonction et la reprend immédiatement par le biais du planificateur de tâchesdu moteur .Des arguments supplémentaires sont transmis au thread ou à la fonction qui est reprise.

L'exemple de code suivant est un exemple de la façon dont vous pouvez utiliser task.spawn() lorsque vous appelez une fonction qui peut produire pendant l'itération sur un ensemble d'objets :

local function playerAdded(player)
    ...
    (yield)
end

for _, player in Players:GetPlayers() do
    task.spawn(playerAdded, player)
end

tâche.defer

task.defer() prend un thread ou une fonction et la reporte jusqu'au prochain cycle de reprise auquel elle est reprise avec le planificateur de tâchesde l'Engine.Des arguments supplémentaires sont transmis au thread ou à la fonction de reprise.

Vous devriez généralement utiliser ceci lorsque vous voulez un comportement similaire à task.spawn() mais que vous ne vous souciez pas du thread qui s'exécute immédiatement.L'exemple de code suivant illustre la manière dont la déclaration print() pour "A" sera reportée jusqu'à ce que la déclaration print() pour "B" soit exécutée :

task.defer(print, "A")
print("B")
--> B
--> A

tâche.delay

task.delay() prend un thread ou une fonction et la programme pour sa reprise après le laps de temps donné sur la prochaine étape Heartbeat.La colonne reprend avec la gestion des erreurs intégrée et le support d'autres fonctionnalités du moteur.Tous les arguments supplémentaires sont transmis au thread ou à la fonction de reprise.

Puisque le temps de retard réel peut varier, l'exemple de code suivant illustre comment vous pouvez le calculer en passant le temps actuel comme argument :

task.delay(2, function(scheduledTime)
	print(os.clock() - scheduledTime) --> 2.038702
end, os.clock())

Une durée de zéro entraînera la reprise du thread ou de la fonction à l'étape suivante.

tâche.wait

task.wait() produit le thread actuel jusqu'à l'expiration de la durée donnée (en secondes) puis reprend le thread à l'étape suivante Heartbeat.

Le temps de rendement réel peut varier. L'exemple de code suivant illustre la façon dont cette méthode le retourne pour convenir :

Puisque le temps de retard réel peut varier, l'exemple de code suivant illustre la façon dont vous pouvez obtenir le temps réel en stockant la valeur de retour de la méthode :

local elapsedTime = task.wait(2) -- attendre 2 secondes
print(elapsedTime) --> 2.0792941

Si aucune durée n'est donnée, la durée sera définie à zéro, ce qui signifie que le thread reprendra automatiquement à l'étape suivante.Cela signifie que task.wait() est équivalent en comportement à RunService.Heartbeat .