Sleep for JavaScript : une pause avec await, sans bloquer le thread

Pour reproduire une fonction sleep en JavaScript, renvoyez une Promise résolue par setTimeout, puis attendez-la avec await. Vous retardez ainsi la suite d’une fonction sans immobiliser le thread principal. Le langage JavaScript ne fournit pas de fonction globale sleep standard : cette petite fonction utilitaire répond au besoin courant d’une pause asynchrone.
Une fonction sleep réutilisable immédiatement
Voici l’implémentation à ajouter à votre code. Le paramètre ms représente le délai en millisecondes :

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
Pour attendre 3 secondes, passez 3000 millisecondes. L’exemple suivant est autonome : il définit sleep, l’utilise dans une fonction async, puis lance cette fonction.
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
async function executer() { console.log("Début"); await sleep(3000); console.log("Fin après la pause"); } executer();
La console affiche « Début », puis « Fin après la pause » lorsque l’attente est terminée. Pour une pause de 2 secondes, utilisez sleep(2000). Une seconde correspond à 1000 millisecondes ; une attente de 5 secondes s’écrit donc sleep(5000).
Ce que renvoie réellement sleep
La fonction ne renvoie pas une durée et ne garde pas le processeur occupé pendant l’intervalle. Elle retourne immédiatement une Promise en attente. Le temporisateur appelle resolve lorsque son callback peut être exécuté, ce qui permet ensuite à la fonction suspendue par await de poursuivre son travail.
Dans cet exemple, await se trouve dans une fonction déclarée async. C’est la forme la plus simple à réutiliser dans un script. L’utilisation d’await au niveau supérieur dépend, elle, du contexte d’exécution, notamment de l’emploi d’un module.
Pourquoi setTimeout seul ne met pas la suite en pause
setTimeout programme une fonction de rappel, aussi appelée callback. Il ne demande pas au code appelant d’attendre. Cette différence explique pourquoi ajouter un temporisateur entre deux instructions ne suffit pas à créer une pause.
console.log("A"); setTimeout(() => console.log("B"), 3000); console.log("C");
L’ordre d’affichage est A, C, puis B. Le programme enregistre le temporisateur et passe immédiatement à l’instruction suivante. Seul l’affichage de B est différé.
Avec une Promise attendue, l’enchaînement devient différent :
async function sequence() { console.log("A"); await sleep(3000); console.log("B"); console.log("C"); } sequence();
Cette fois, l’ordre est A, puis B et C après l’attente. La fonction sequence ne franchit pas await tant que la Promise n’est pas résolue.
La chronologie à garder en tête
- L’appel à sleep crée une Promise et enregistre un temporisateur.
- await suspend la progression de la fonction async concernée.
- Le reste de l’application peut poursuivre ses autres tâches.
- Après expiration du délai, le callback du temporisateur peut être exécuté et résout la Promise.
- La continuation de la fonction async est ensuite exécutée.
Si vous transmettez une fonction existante à setTimeout, donnez sa référence : setTimeout(continuer, 3000). Écrire continuer() l’exécuterait immédiatement et transmettrait son résultat au temporisateur, au lieu de programmer son appel.
Attendre sans bloquer : la différence qui protège votre application
await suspend une fonction, pas l’ensemble du thread. Dans un navigateur, une attente asynchrone laisse la possibilité de traiter les interactions et les autres tâches. Dans un serveur JavaScript, elle permet également de laisser avancer d’autres opérations au lieu de monopoliser l’exécution.
Maîtriser les promesses en JavaScript : La documentation officielle de MDN explique comment utiliser les promesses pour gérer efficacement les opérations asynchrones en JavaScript.
Imaginez le thread comme un corridor partagé. Une boucle d’attente active reste plantée au milieu du passage en consultant continuellement l’heure ; les autres tâches ne peuvent plus circuler sur ce même thread. Avec await, la fonction se met sur le côté et attend son signal de reprise. Cette distinction aide à diagnostiquer un problème : si l’interface se fige pendant une prétendue pause, cherchez une opération synchrone qui occupe le passage, pas seulement un temporisateur trop long.
| Méthode | Effet sur les instructions suivantes | Effet sur le thread |
|---|---|---|
| setTimeout seul | Elles continuent immédiatement ; seul le callback est différé. | Pas de blocage pendant l’attente. |
| Promise et setTimeout avec await | La suite de la fonction async attend la résolution. | Pas de blocage pendant l’attente. |
| Boucle d’attente active | Elles attendent la sortie de la boucle. | Le thread reste occupé. |
La boucle basée sur l’horloge est un mauvais remplacement
Une boucle qui compare continuellement l’heure actuelle à une heure de fin produit bien un blocage synchrone. Elle consomme toutefois du temps processeur et empêche les autres tâches JavaScript de s’exécuter sur le même thread. Dans une page web, cela peut rendre les boutons et l’affichage non réactifs.
Une attente asynchrone ne rend pas non plus les calculs lourds non bloquants par magie. Si une longue opération synchrone commence après await, elle peut toujours monopoliser le thread. La pause et le traitement sont deux problèmes distincts.
Employer les délais au bon endroit, sans masquer un problème
Une fonction sleep est utile lorsqu’un intervalle fait réellement partie du comportement souhaité. Elle devient fragile lorsqu’elle sert seulement à deviner à quel moment une ressource sera prête.
Espacer des appels successifs
Pour traiter une liste avec une attente entre les requêtes, utilisez une boucle dont chaque opération est attendue. L’exemple suivant suppose que sleep est définie et que urls contient les adresses à interroger :
async function charger(urls) { for (const url of urls) { const reponse = await fetch(url); console.log(reponse.status); await sleep(1000); } }
Cette version attend une seconde après chaque réponse, y compris la dernière. Elle n’établit donc pas une cadence exacte d’un départ par seconde : le temps de la requête s’ajoute à la pause. Pour respecter une limite d’API, tenez aussi compte des requêtes lancées ailleurs dans l’application et des consignes du service.
Évitez de remplacer cette boucle par forEach avec un callback async en espérant obtenir le même séquencement : forEach n’attend pas les Promises renvoyées par ses callbacks.
Tests, débogage et animations : choisir le bon signal
Une pause permet de simuler une latence réseau ou de ralentir une démonstration pour observer les étapes. En revanche, dans un test, attendre arbitrairement plusieurs secondes ne garantit pas qu’un chargement sera terminé. Attendre la Promise de l’opération ou un événement précis donne généralement un résultat plus fiable.
Pour une animation, sleep peut séparer deux étapes, mais ne constitue pas une horloge d’affichage précise. Les animations visuelles continues bénéficient plutôt de mécanismes adaptés au rendu, comme requestAnimationFrame.
- Ne supposez pas une reprise à la milliseconde exacte : un thread occupé ou les restrictions d’un onglet en arrière-plan peuvent retarder le temporisateur.
- N’oubliez pas await : appeler sleep(1000) seul crée une Promise sans retarder les instructions suivantes.
- Gardez les délais justifiés : une longue attente asynchrone ne bloque pas le thread, mais peut donner l’impression que l’application ne répond plus.
- Prévoyez les changements d’état : cette fonction minimale ne propose pas d’annulation ; vérifiez que l’action reste pertinente après l’attente.
Le bon réflexe reste simple : utilisez sleep pour attendre une durée, et attendez directement une opération lorsque vous cherchez son résultat.