Accepts a function or a thread (as returned by coroutine.create) and
calls/resumes it immediately through the engine's scheduler. Arguments
after the first are sent to the function/thread. This function does not
return any value, even if the provided function returns one immediately.

This function is based on the fastSpawn pattern rather than being a
replacement for the deprecated global `spawn` function. It is recommended
that this function be used in place of fastSpawn.

If the calling script is currently running in a serial execution phase,
then the spawned function or thread is resumed in the current serial
execution phase. If the calling script is currently running in a parallel
execution phase, then the spawned function or thread is resumed in the
current parallel execution phase. For more information, see
[Parallel Luau](/scripting/multithreading).


task.spawn

functionOrThread

A function or a thread returned by coroutine.create.


Arguments to send to the function or thread.


Calls/resumes a function/coroutine immediately through the engine
scheduler.


Accepts a function or a thread (as returned by coroutine.create) and
defers it until the next
[resumption cycle](https://devforum.roblox.com/t/1240569), at which point
it is resumed with the engine's scheduler like with
`Library.task.spawn()`. Arguments after the first are sent to the
function/thread. This function does not return any value, even if the
provided function returns one immediately.

This function should be used when a similar behavior to
`Library.task.spawn()` is desirable, but the thread does not need to run
immediately.

If the calling script is currently running in a serial execution phase,
then the deferred function or thread is resumed in a serial execution
phase. If the calling script is currently running in a parallel execution
phase, then the deferred function or thread is resumed in a parallel
execution phase. For more information, see
[Parallel Luau](/scripting/multithreading).


task.defer

Calls/resumes a function/coroutine on the next resumption cycle.


Accepts a function or a thread (as returned by coroutine.create) and
schedules it to be called/resumed on the next
`Class.RunService.Heartbeat|Heartbeat` after the given amount of time in
seconds has elapsed. Arguments after the second are sent to the
function/thread.

This function differs from the deprecated global `delay` function in that
**no throttling occurs**: on the very same Heartbeat step in which enough
time has passed, the function is guaranteed to be called/resumed.
Providing a duration of zero (0) will guarantee that the function is
called on the very next Heartbeat.

You can calculate the actual time passed by calling `Library.os.clock()`
upon scheduling and in the scheduled function.

If the calling script is currently running in a serial execution phase,
then the delayed function or thread is resumed in a serial execution
phase. If the calling script is currently running in a parallel execution
phase, then the delayed function or thread is resumed in a parallel
execution phase. For more information, see
[Parallel Luau](/scripting/multithreading).


task.delay

duration

The minimum number of seconds that must pass before the
function/thread is called/resumed.


Arguments to be passed to the function/thread when it is due to be
called/resumed.


Schedules a function/coroutine to be called/resumed on the next Heartbeat
after the given duration (in seconds) has passed, without throttling.


If the calling script is currently running in a serial execution phase,
`desynchronize` suspends the script and the script will be resumed in the
next parallel execution phase. If the calling script is currently running
in a parallel execution phase, `desynchronize` returns immediately and has
no effect.

Only scripts which are descendants of an Actor may call this method. If a
script outside of an Actor calls this method, an error will be raised.
ModuleScript's may also call `desynchronize` as long as the instantiation
of the module calling it was required by a script that is a descendant of
an Actor.

For more information, see
[Parallel Luau](/scripting/multithreading).


task.desynchronize

Causes the following code to be run in parallel.


If the calling script is currently running in a parallel execution phase,
`synchronize` suspends the script and the script will be resumed in the
next serial execution phase. If the calling script is currently running in
a serial execution phase, `synchronize` returns immediately and has no
effect.

Only scripts which are descendants of an Actor may call this method. If a
script outside of an Actor calls this method, an error will be raised.
ModuleScript's may also call `synchronize` as long as the instantiation of
the module calling it was required by a script that is a descendant of an
Actor.

For more information, see
[Parallel Luau](/scripting/multithreading).


task.synchronize

Causes the following code to be run in serial.


Yields the current thread until the given duration (in seconds) has
elapsed, then resumes the thread on the next
`Class.RunService.Heartbeat|Heartbeat` step. The actual amount of time
elapsed is returned.

If no duration is given, it will default to zero (0). This means the
thread resumes on the very next step, which is equivalent in behavior to
`RunService.Heartbeat:Wait()`

Unlike the deprecated global `wait`, this function **does not throttle**
and guarantees the resumption of the thread on the first Heartbeat that
occurs when it is due. This function also only returns the elapsed time
and nothing else.

If the calling script is currently running in a serial execution phase,
then the script is resumed in a serial execution phase. If the calling
script is currently running in a parallel execution phase, then the script
is resumed in a parallel execution phase. For more information, see
[Parallel Luau](/scripting/multithreading).


task.wait

The amount of time in seconds that should elapse before the current
thread is resumed.


Yields the current thread until the next Heartbeat in which the given
duration (in seconds) has passed, without throttling.


Cancels a thread and closes it, preventing it from being resumed manually
or by the task scheduler.

This function can be used with other members of the task library that
return a thread to cancel them before they are resumed. For example:

```lua
local thread = task.delay(5, function ()
  print("Hello world!")
end)

task.cancel(thread)
```

Note: Threads may be in a state where it is impossible to cancel them. For
example, the currently executing thread and threads that have resumed
another coroutine may not be cancelled. If this is the case, a lua error
will be generated.

However, code should not rely on specific thread states or conditions
causing `Library.task.cancel()` to fail. It is possible that future
updates will eliminate these constraints and allow threads in these states
to be successfully cancelled.


task.cancel

thread

Cancels a thread, preventing it from being resumed.


task

Allows for functions and threads to be coordinated with the Task Scheduler.


An object that runs connected functions upon a specific occurrence.

Data Type

RBXScriptSignal

Variant

Functions are blocks of code that can execute multiple times on command.

Luau

function

A double-precision floating-point number.

number

A function that executes alongside the main thread.

Library

coroutine

void

Vue d'ensemble

Guides

Tutoriels

Référence

Ressources

Conception

Moteur

Avatar

Cloud

Ce champ peut être défini lors de la création d'une ressource, mais ne peut pas être modifié par des requêtes ultérieures.

Ce champ peut être fourni dans les demandes, mais ne sera jamais inclus dans les réponses.

Par clé API : {maxInPeriod} demande toutes les {periodInSeconds} secondes par adresse IP

Ce champ peut être défini sur les réponses, mais sera ignoré dans les demandes.

Les autorisations suivantes de la clé API sont requises pour appeler ce point de terminaison. Pour plus
d'informations sur la génération de clés appropriées, voir [Gestion des clés d'API] ({apiKeyReferenceDocLink}).

Les points de terminaison suivants sont disponibles à des chemins relatifs à l'URL de base.

Cette chaîne est formatée comme un [FieldMask](/cloud/reference/types#fieldmask).

Une valeur JSON peut être `null`, `boolean`, `string`, `number`, `array`, ou `object`.

Les champs d'application suivants sont nécessaires pour que votre application OAuth 2.0 puisse utiliser ce point de terminaison. Pour plus d'informations sur l'enregistrement d'une application OAuth 2.0, voir [Enregistrement et révisions des applis]({oauth2ReferenceDocLink}).

Les objets suivants décrivent les charges utiles qui sont acceptées ou renvoyées. Voir chaque point de terminaison individuel pour plus d'informations sur l'utilisation de ces objets.

Ce string est formatée en tant que [Timestamp](/cloud/reference/types#timestamp).

Les champs d'application suivants sont nécessaires pour que votre application OAuth 2.0 puisse utiliser ce point de terminaison. Pour plus d'informations sur l'enregistrement d'une application OAuth 2.0, voir [Enregistrement et révision d'une application]. ({oauth2ReferenceDocLink}).

Cela permet de consulter des informations sur vos contenus.

Il permet de télécharger et de mettre à jour des actifs sur Roblox.

Cela vous permet d'afficher des informations sur vos produits de la Boutique du créateur.

Cela permet d'afficher des informations sur vos groupes.

Cela vous permet de gérer les demandes d'adhésion de groupe pour votre compte.

Cela permet de publier des messages au nom des utilisateurs.

Cela permet d'envoyer des notifications de votre expérience aux utilisateurs

Cela permet d'énumérer les secrets liés à ton expérience.

Cela permet de créer et de mettre à jour des secrets liés à ton expérience.

Donne la capacité de lire les informations sur les lieux.

Donne la possibilité d'éditer les informations du lieu.

Cette opération donne accès à la publication de nouvelles versions d'expériences à Roblox.

Donne la possibilité de lire des informations sur l'expérience.

Donne la possibilité de modifier les informations d'expérience.

Permet de voir les restrictions de l'utilisateur dans l'expérience.

Vous permet de modifier les restrictions d'utilisateur dans l'expérience.

Donne la possibilité de lire le statut premium et vérifié de l'utilisateur.

Cela vous permet de voir les comptes sociaux d'un utilisateur.

Cela active la fonctionnalité Single Sign-On

Cela vous donne accès à la lecture des informations de votre profil

Valeur par défaut : {defaultValueStart}{defaultValueEnd}

Un tableau est une liste ordonnée de valeurs. Les tableaux sont utiles pour stocker des collections de données.

Un ensemble de paires clé-valeur, où les clés peuvent être n'importe quel nombre, chaîne ou objet.

Cette fonction revient immédiatement si possible, mais peut céder le thread qui l'a appelée jusqu'à ce qu'elle puisse retourner une valeur.

{nameStart}nom{nameEnd} n'est plus supporté ou maintenu par Roblox.

Cette opération mathématique n'est plus prise en charge ou maintenue par Roblox.

Ce membre n'apparaît pas dans le navigateur d'objet et n'est pas destiné à une utilisation généralisée.

Ce membre n'est accessible que via la barre de commande. Tenter d'accéder à ce membre à partir de scripts provoque une erreur.

Cette fonction ne peut pas mettre en pause le thread Lua qui l’appelle.

Tenter d'accéder à ce membre dans les scripts provoque une erreur. Tu peux accéder à ce membre à partir de la fenêtre de propriété de Roblox Studios.

Ce membre n’apparaît pas dans le navigateur Objet de Roblox Studio.

Tu ne peux pas créer une instance de cette classe avec le constructeur Instance.new .

Roblox ne réplique pas ce membre à travers sa limite client serveur.

Le code Lua ne peut pas accéder à ce membre. Tu pourrais être en mesure de changer sa valeur depuis la fenêtre de la propriété dans Roblox Studio.

Le comportement de réplication de cet objet dépend du joueur qui le possède.

Ce membre n'est accessible que par le biais de la barre de commandes et des plugins uniquement. Tenter d'accéder à ce membre à partir de scripts provoque une erreur.

Ce membre est en lecture seule. Tenter d'écrire à ce membre provoque une erreur.

Cette propriété est en lecture seule et peut être lue en toute sécurité dans les threads non synchronisés. Toute tentative d'écriture dans cette propriété entraîne une erreur.

Ce membre n'est accessible que dans CoreScripts.

Seul Roblox CoreScripts peut accéder à ce membre, et il n’est pas utilisable par les joueurs.

Tu peux lire et écrire cette propriété en toute sécurité à partir de plusieurs threads.

Cette classe est un singleton de premier niveau. Récupére une instance de cette classe avec la fonction GetService.

Plusieurs threads peuvent potentiellement écrire dans cette propriété, donc il n'est pas sûr de lire à partir de threads non synchronisés.

Vous pouvez lire et écrire sur cette propriété en toute sécurité à partir de plusieurs threads.

Cette fonction met en pause le thread Lua qui l'a appelée jusqu'à ce qu'elle renvoie un résultat. Cela n'interrompt pas les autres scripts.

Apprenez à créer du contenu réussi sur Roblox avec des guides, des échantillons de code, des références et des tutoriels.


{pageTitle} | {SiteName}

titre

Impossible d'ajouter à l'inventaire

L'exemple de code {title} a été ajouté à votre inventaire.

La version {versionNumber} inclut des améliorations générales des performances et des corrections de bugs. Consultez nos autres notes de publication pour connaître l'état des améliorations et des bugs spécifiques.

Veuillez ne pas inclure d'informations privées ou personnelles. {maxDescriptionLength} mots maximum.

Minimum {minDescriptionLength} mots requis dans la description.

Notes de publication pour la version Roblox Studio {versionNumber}

Nous préparons des choses encore plus étonnantes. Merci de votre patience.

En cliquant sur "Continuer", vous serez dirigé vers {redirectLinkStart}{redirectLinkEnd}

Ce site n'est pas détenu ou exploité par Roblox. Ils peuvent avoir des conditions et des politiques de confidentialité différentes.

task

Résumé

Fonctions

Fonctions

spawn

Paramètres

Retours

defer

Paramètres

Retours

delay

Paramètres

Retours

desynchronize

Retours

synchronize

Retours

wait

Paramètres

Retours

cancel

Paramètres

Retours