Quelle est la version JavaScript de sleep ()?

Existe-t-il un meilleur moyen de créer un sleepfichier JavaScript que la pausecompfonction suivante ( prise ici )?

function pausecomp(millis)
{
    var date = new Date();
    var curDate = null;
    do { curDate = new Date(); }
    while(curDate-date < millis);
}

Ce n'est pas un doublon de Sleep in JavaScript - délai entre les actions ; Je veux un vrai sommeil au milieu d'une fonction, et non pas un délai avant qu'un morceau de code ne s'exécute.

Mise à jour 2017-2019

Depuis 2009, date à laquelle cette question a été posée, JavaScript a considérablement évolué. Toutes les autres réponses sont désormais obsolètes ou trop compliquées. Voici la meilleure pratique actuelle:

function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function demo() {
  console.log('Taking a break...');
  await sleep(2000);
  console.log('Two seconds later, showing sleep in a loop...');

  // Sleep in loop
  for (let i = 0; i < 5; i++) {
    if (i === 3)
      await sleep(2000);
    console.log(i);
  }
}

demo();

Ça y est. await sleep(<duration>).

Ou en monoplace:

await new Promise(r => setTimeout(r, 2000));

Notez que,

1. awaitne peut être exécuté que dans des fonctions préfixées par le asyncmot - clé, ou au niveau supérieur de votre script dans certains environnements (par exemple la console Chrome DevTools ou Runkit).
2. awaitsuspend uniquement la asyncfonction actuelle

Deux nouvelles fonctionnalités JavaScript ont aidé à écrire cette fonction "veille":

• Promises, une fonctionnalité native d'ES2015 (alias ES6). Nous utilisons également des fonctions fléchées dans la définition de la fonction sommeil.
• La async/awaitfonctionnalité permet au code d'attendre explicitement qu'une promesse soit réglée (résolue ou rejetée).

Compatibilité

• les promesses sont prises en charge dans Node v0.12 + et largement prises en charge dans les navigateurs , sauf IE
• async/ a awaitatterri dans V8 et est activé par défaut depuis Chrome 55 (sorti en décembre 2016)
  • il a atterri dans le nœud 7 en octobre 2016
  • et a également atterri dans Firefox Nightly en novembre 2016

Si, pour une raison étrange, vous utilisez Node plus de 7 (qui a atteint la fin de sa vie ), ou ciblez d'anciens navigateurs, async/ awaitpeut toujours être utilisé via Babel (un outil qui transposera JavaScript + de nouvelles fonctionnalités en ancien JavaScript). , avec le transform-async-to-generatorplugin.

(Voir la réponse mise à jour pour 2016 )

Je pense qu'il est parfaitement raisonnable de vouloir effectuer une action, attendre, puis effectuer une autre action. Si vous avez l'habitude d'écrire dans des langages multithreads, vous avez probablement l'idée de céder l'exécution pendant un certain temps jusqu'à ce que votre thread se réveille.

Le problème ici est que JavaScript est un modèle basé sur des événements à un seul thread. Alors que dans un cas spécifique, il peut être agréable de laisser le moteur entier attendre quelques secondes, en général c'est une mauvaise pratique. Supposons que je veuille utiliser vos fonctions tout en écrivant les miennes? Lorsque j'appelais votre méthode, mes méthodes se bloquaient toutes. Si JavaScript pouvait en quelque sorte préserver le contexte d'exécution de votre fonction, le stocker quelque part, puis le ramener et continuer plus tard, alors le sommeil pourrait se produire, mais ce serait essentiellement du filetage.

Donc, vous êtes à peu près coincé avec ce que d'autres ont suggéré - vous devrez diviser votre code en plusieurs fonctions.

Votre question est donc un peu un faux choix. Il n'y a aucun moyen de dormir comme vous le souhaitez et vous ne devez pas non plus poursuivre la solution que vous proposez.

En JavaScript, je réécris chaque fonction pour qu'elle se termine le plus rapidement possible. Vous voulez que le navigateur reprenne le contrôle afin qu'il puisse apporter vos modifications DOM.

Chaque fois que je voulais dormir au milieu de ma fonction, je refactorisais d'utiliser un setTimeout().

Éditer

La fameuse fonction de sommeil ou de retard dans n'importe quelle langue est très controversée. Certains diront qu'il devrait toujours y avoir un signal ou un rappel pour déclencher une fonctionnalité donnée, d'autres diront que parfois un moment de retard arbitraire est utile. Je dis qu'à chacun sa règle et qu'une règle ne peut jamais dicter quoi que ce soit dans cette industrie.

L'écriture d'une fonction de veille est simple et encore plus utilisable avec JavaScript Promises:

// sleep time expects milliseconds
function sleep (time) {
  return new Promise((resolve) => setTimeout(resolve, time));
}

// Usage!
sleep(500).then(() => {
    // Do something after the sleep!
});

Uniquement pour debug / dev , je poste ceci si c'est utile à quelqu'un

Des choses intéressantes, dans Firebug (et probablement d'autres consoles js), rien ne se passe après avoir appuyé sur enter, seulement après la durée de sommeil spécifiée (...)

function sleepFor( sleepDuration ){
    var now = new Date().getTime();
    while(new Date().getTime() < now + sleepDuration){ /* do nothing */ } 
}

Exemple d'utilisation:

function sleepThenAct(){ sleepFor(2000); console.log("hello js sleep !"); }

Je suis d'accord avec les autres affiches, un sommeil occupé n'est qu'une mauvaise idée.

Cependant, setTimeout ne retarde pas l'exécution, il exécute la ligne suivante de la fonction immédiatement après que le délai d'expiration est défini, pas après l'expiration du délai d'expiration, de sorte que n'accomplit pas la même tâche qu'un sommeil accomplirait.

La façon de le faire est de décomposer votre fonction en parties avant et après.

function doStuff()
{
  //do some things
  setTimeout(continueExecution, 10000) //wait ten seconds before continuing
}

function continueExecution()
{
   //finish doing things after the pause
}

Assurez-vous que les noms de vos fonctions décrivent toujours avec précision ce que fait chaque élément (IE GatherInputThenWait et CheckInput, plutôt que funcPart1 et funcPart2)

Éditer

Cette méthode atteint l'objectif de ne pas exécuter les lignes de code que vous décidez jusqu'à APRÈS votre délai d'expiration, tout en renvoyant le contrôle au PC client pour exécuter tout ce qu'il a mis en file d'attente.

Modifier davantage

Comme indiqué dans les commentaires, cela ne fonctionnera absolument PAS en boucle. Vous pouvez faire un piratage sophistiqué (moche) pour le faire fonctionner en boucle, mais en général, cela ne fera que créer un code de spaghetti désastreux.

Pour l'amour de $ DEITY, ne faites pas de fonction de veille d'attente. setTimeoutet setIntervalfaites tout ce dont vous avez besoin.

var showHide = document.getElementById('showHide');
setInterval(() => {
    showHide.style.visibility = "initial";
    setTimeout(() => {
        showHide.style.visibility = "hidden"
    }, 1000);
    ;
}, 2000);   

<div id="showHide">Hello! Goodbye!</div>

Toutes les deux secondes, masquez le texte pendant une seconde. Cela montre comment utiliser setInterval et setTimeout pour afficher et masquer le texte chaque seconde.

Je sais que c'est un peu une vieille question, mais si (comme moi) vous utilisez Javascript avec Rhino, vous pouvez utiliser ...

try
{
  java.lang.Thread.sleep(timeInMilliseconds);
}
catch (e)
{
  /*
   * This will happen if the sleep is woken up - you might want to check
   * if enough time has passed and sleep again if not - depending on how
   * important the sleep time is to you.
   */
}

Si vous utilisez jQuery, quelqu'un a en fait créé un plugin "delay" qui n'est rien de plus qu'un wrapper pour setTimeout:

// Delay Plugin for jQuery
// - http://www.evanbot.com
// - © 2008 Evan Byrne

jQuery.fn.delay = function(time,func){
    this.each(function(){
        setTimeout(func,time);
    });

    return this;
};

Vous pouvez ensuite simplement l'utiliser dans une ligne d'appels de fonction comme prévu:

$('#warning')
.addClass('highlight')
.delay(1000)
.removeClass('highlight');

J'ai également cherché une solution de sommeil (pas pour le code de production, seulement pour les dev / tests) et j'ai trouvé cet article:

http://narayanraman.blogspot.com/2005/12/javascript-sleep-or-wait.html

... et voici un autre lien avec les solutions côté client: http://www.devcheater.com/

De plus, lorsque vous appelez alert(), votre code sera également mis en pause, tandis que l'alerte est affichée - vous devez trouver un moyen de ne pas afficher l'alerte mais d'obtenir le même effet. :)

Voici une solution simple utilisant un XMLHttpRequest synchrone:

function sleep(n){
  var request = new XMLHttpRequest();
  request.open('GET', '/sleep.php?n=' + n, false);  // `false` makes the request synchronous
  request.send(null);
}

contenu de sleep.php:

<?php sleep($_GET['n']);

Maintenant, appelez-le avec: sommeil (5);

Voici. Comme le dit le code, ne soyez pas un mauvais développeur et utilisez-le sur des sites Web. C'est une fonction utilitaire de développement.

// Basic sleep function based on ms.
// DO NOT USE ON PUBLIC FACING WEBSITES.
function sleep(ms) {
    var unixtime_ms = new Date().getTime();
    while(new Date().getTime() < unixtime_ms + ms) {}
}

Personnellement, j'aime le simple:

function sleep(seconds){
    var waitUntil = new Date().getTime() + seconds*1000;
    while(new Date().getTime() < waitUntil) true;
}

puis:

sleep(2); // Sleeps for 2 seconds

Je l'utilise tout le temps pour créer de faux temps de chargement lors de la création de scripts dans P5js

Première:

Définissez une fonction que vous souhaitez exécuter comme ceci:

function alertWorld(){
  alert("Hello World");
}

Planifiez ensuite son exécution avec la méthode setTimeout:

setTimeout(alertWorld,1000)

Notez deux choses

• le deuxième argument est le temps en millisecondes
• comme premier argument, vous devez passer juste le nom (référence) de la fonction, sans la parenthèse

  await new Promise(resolve => setTimeout(resolve, 2000));

assurez-vous que votre fonction d'appel est asynchrone

vérifié et fonctionne bien

La meilleure solution pour que les choses ressemblent à ce que la plupart des gens veulent est d'utiliser une fonction anonyme:

alert('start');
var a = 'foo';
//lots of code
setTimeout(function(){  //Beginning of code that should run AFTER the timeout
    alert(a);
    //lots more code
},5000);  // put the timeout here

C'est probablement le plus proche de quelque chose qui fait simplement ce que vous voulez.

Notez que si vous avez besoin de plusieurs sommeil, cela peut devenir très vite pressé et vous devrez peut-être repenser votre conception.

Pour les navigateurs, je conviens que setTimeout et setInterval sont la voie à suivre.

Mais pour le code côté serveur, il peut nécessiter une fonction de blocage (par exemple, afin que vous puissiez effectivement avoir la synchronisation des threads).

Si vous utilisez node.js et meteor, vous pouvez avoir rencontré les limites de l'utilisation de setTimeout dans une fibre. Voici le code de mise en veille côté serveur.

var Fiber = require('fibers');

function sleep(ms) {
    var fiber = Fiber.current;
    setTimeout(function() {
        fiber.run();
    }, ms);
    Fiber.yield();
}

Fiber(function() {
    console.log('wait... ' + new Date);
    sleep(1000);
    console.log('ok... ' + new Date);
}).run();
console.log('back in main');

Voir: https://github.com/laverdet/node-fibers#sleep

J'encapsulerais setTimeOut dans une promesse de cohérence du code avec d'autres tâches asynchrones: Démo dans Fiddle

function sleep(ms)
{
    return(new Promise(function(resolve, reject) {        
        setTimeout(function() { resolve(); }, ms);        
    }));    
}

Utilisé comme ça:

sleep(2000).then(function() { 
   // Do something
});

Il est facile de se souvenir de la syntaxe si vous utilisiez auparavant Promises.

Mise à jour 2019 à l'aide d' Atomics.wait

Devrait fonctionner dans le nœud 9.3 ou supérieur.

J'avais besoin d'une minuterie assez précise dans Node.js et cela fonctionne très bien pour cela. Cependant, il semble que le support des navigateurs soit extrêmement limité.

let ms = 10000;
Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);

A exécuté quelques repères de minuterie de 10 secondes.

Avec setTimeout, j'obtiens une erreur allant jusqu'à 7000 microsecondes. (7 ms)

Avec Atomics, mon erreur semble rester inférieure à 600 microsecondes. (0,6 ms)

Mise à jour 2020: en résumé

function sleep(millis){ // need help of a server-side page
  let netMillis=Math.max(millis-5,0); //assuming 5ms overhead
  let xhr=new XMLHttpRequest();
  xhr.open('GET','/sleep.jsp?millis='+netMillis+'&rand='+Math.random(), false);
  try{
    xhr.send();
  }catch(e){
  }
}
function sleepAsync(millis){ // use only in async function
  let netMillis=Math.max(millis-1,0); // assuming 1ms overhead
  return new Promise((resolve)=>{
    setTimeout(resolve, netMillis);
  });
}
function sleepSync(millis){ // use only in worker thread, currently Chrome-only
  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, millis);
}

function sleepTest(){
  console.time('sleep');
  sleep(1000);
  console.timeEnd('sleep');
}
async function sleepAsyncTest(){
  console.time('sleepAsync');
  await sleepAsync(1000);
  console.timeEnd('sleepAsync');
}
function sleepSyncTest(){ 
  let source=`${sleepSync.toString()}
    console.time('sleepSync');
    sleepSync(1000);
    console.timeEnd('sleepSync');`;
  let src='data:text/javascript,'+encodeURIComponent(source);
  console.log(src);
  var worker=new Worker(src);
}

dont la page côté serveur, par exemple sleep.jsp, ressemble à

<%
try{
  Thread.sleep(Long.parseLong(request.getParameter("millis")));
}catch(InterruptedException e){}
%>

La plupart des réponses ici sont erronées ou pour le moins dépassées. Il n'y a aucune raison que le javascript doive être monothread, et ce n'est pas le cas. Aujourd'hui, tous les navigateurs traditionnels prennent en charge les travailleurs, avant que ce ne soit le cas d'autres runtimes javascript comme Rhino et Node.js prennent en charge le multithreading.

'Javascript is single threaded' n'est pas une réponse valide. Par exemple, l'exécution d'une fonction de veille au sein d'un travailleur ne bloquerait aucun du code exécuté dans le thread d'interface utilisateur.

Dans les runtimes plus récents prenant en charge les générateurs et le rendement, on pourrait apporter des fonctionnalités similaires à la fonction de veille dans un environnement à thread unique:

// This is based on the latest ES6 drafts.
// js 1.7+ (SpiderMonkey/Firefox 2+) syntax is slightly different

// run code you want to sleep here (ommit star if using js 1.7)
function* main(){
    for (var i = 0; i < 10; i++) {
        // to sleep for 10 milliseconds 10 times in a row
        yield 10;
    }

    yield 5;
    console.log('I just slept 5 milliseconds!');
}

// resume the given generator after ms milliseconds
function resume(ms, generator){
    setTimeout(function(){
        // ommit .value if using js 1.7
        var nextSleep = generator.next().value;
        resume(nextSleep, generator);
    }, ms);
}

// initialize generator and get first sleep for recursive function
var
    generator = main(),
    firstSleep = generator.next().value;

// initialize recursive resume function
resume(firstSleep, generator);

Cette imitation du sommeil est différente d'une véritable fonction de sommeil car elle ne bloque pas le thread. C'est simplement du sucre en plus de la fonction setTimeout actuelle de javascript. Ce type de fonctionnalité a été implémenté dans Task.js et devrait fonctionner aujourd'hui dans Firefox.

J'ai recherché / googlé pas mal de pages Web sur le sommeil / l'attente de Javascript… et il n'y a PAS de réponse si vous voulez que Javascript soit à "RUN, DELAY, RUN" ... ce que la plupart des gens ont obtenu était "RUN, RUN (inutile ) "RUN" ou "RUN, RUN + RUN retardé" ....

J'ai donc mangé des hamburgers et j'ai réfléchi ::: voici une solution qui fonctionne ... mais vous devez couper vos codes de fonctionnement ... ::: oui, je sais, c'est juste un refactoring plus facile à lire .. . encore...

//......................................... //Exemple 1:

<html>
<body>
<div id="id1">DISPLAY</div>

<script>
//javascript sleep by "therealdealsince1982"; copyrighted 2009
//setInterval
var i = 0;

function run() {
    //pieces of codes to run
    if (i==0){document.getElementById("id1").innerHTML= "<p>code segment "+ i +" is ran</p>"; }
    if (i==1){document.getElementById("id1").innerHTML= "<p>code segment "+ i +" is ran</p>"; }
    if (i==2){document.getElementById("id1").innerHTML= "<p>code segment "+ i +" is ran</p>"; }
    if (i >2){document.getElementById("id1").innerHTML= "<p>code segment "+ i +" is ran</p>"; }
    if (i==5){document.getElementById("id1").innerHTML= "<p>all code segment finished running</p>"; clearInterval(t); } //end interval, stops run
    i++; //segment of code finished running, next...
}

run();
t=setInterval("run()",1000);

</script>
</body>
</html>

// .................................... // exemple2:

<html>
<body>
<div id="id1">DISPLAY</div>

<script>
//javascript sleep by "therealdealsince1982"; copyrighted 2009
//setTimeout
var i = 0;

function run() {
    //pieces of codes to run, can use switch statement
    if (i==0){document.getElementById("id1").innerHTML= "<p>code segment "+ i +" ran</p>"; sleep(1000);}
    if (i==1){document.getElementById("id1").innerHTML= "<p>code segment "+ i +" ran</p>"; sleep(2000);}
    if (i==2){document.getElementById("id1").innerHTML= "<p>code segment "+ i +" ran</p>"; sleep(3000);}
    if (i==3){document.getElementById("id1").innerHTML= "<p>code segment "+ i +" ran</p>";} //stops automatically
    i++;
}

function sleep(dur) {t=setTimeout("run()",dur);} //starts flow control again after dur

run(); //starts
</script>
</body>
</html>

// ................. exemple3:

<html>
<body>
<div id="id1">DISPLAY</div>

<script>
//javascript sleep by "therealdealsince1982"; copyrighted 2009
//setTimeout
var i = 0;

function flow() {
    run(i);
    i++; //code segment finished running, increment i; can put elsewhere
    sleep(1000);
    if (i==5) {clearTimeout(t);} //stops flow, must be after sleep()
}

function run(segment) {
    //pieces of codes to run, can use switch statement
    if (segment==0){document.getElementById("id1").innerHTML= "<p>code segment "+ segment +" is ran</p>"; }
    if (segment==1){document.getElementById("id1").innerHTML= "<p>code segment "+ segment +" is ran</p>"; }
    if (segment==2){document.getElementById("id1").innerHTML= "<p>code segment "+ segment +" is ran</p>"; }
    if (segment >2){document.getElementById("id1").innerHTML= "<p>code segment "+ segment +" is ran</p>"; }
}

function sleep(dur) {t=setTimeout("flow()",dur);} //starts flow control again after dur

flow(); //starts flow
</script>
</body>
</html>

// .............. exemple4:

<html>
<body>
<div id="id1">DISPLAY</div>

<script>
//javascript sleep by "therealdealsince1982"; copyrighted 2009
//setTimeout, switch
var i = 0;

function flow() {
    switch(i)
    {
        case 0:
            run(i);
            sleep(1000);
            break;
        case 1:
            run(i);
            sleep(2000);
            break;
        case 5:
            run(i);
            clearTimeout(t); //stops flow
            break;
        default:
            run(i);
            sleep(3000);
            break;
    }
}

function run(segment) {
    //pieces of codes to run, can use switch statement
    if (segment==0){document.getElementById("id1").innerHTML= "<p>code segment "+ segment +" is ran</p>"; }
    if (segment==1){document.getElementById("id1").innerHTML= "<p>code segment "+ segment +" is ran</p>"; }
    if (segment==2){document.getElementById("id1").innerHTML= "<p>code segment "+ segment +" is ran</p>"; }
    if (segment >2){document.getElementById("id1").innerHTML= "<p>code segment "+ segment +" is ran</p>"; }
    i++; //current segment of code finished running, next...
}

function sleep(dur) {t=setTimeout("flow()",dur);} //starts flow control again after dur

flow(); //starts flow control for first time...
</script>
</body>
</html>

function sleep(milliseconds) {
  var start = new Date().getTime();
  for (var i = 0; i < 1e7; i++) {
    if ((new Date().getTime() - start) > milliseconds){
      break;
    }
  }
}

La solution la plus courte sans dépendances:

await new Promise(resolve => setTimeout(resolve, 5000));

Vous ne pouvez pas faire un sommeil comme ça en JavaScript, ou, plutôt, vous ne devriez pas. L'exécution d'une veille ou d'une boucle while entraîne le blocage du navigateur de l'utilisateur jusqu'à ce que la boucle soit terminée.

Utilisez une minuterie, comme spécifié dans le lien que vous avez référencé.

Un scénario où vous voudrez peut-être une fonction sleep () plutôt que d'utiliser setTimeout () est si vous avez une fonction répondant à un clic de l'utilisateur qui finira par ouvrir une nouvelle fenêtre contextuelle, et que vous avez initié un traitement qui nécessite une courte période pour terminer avant que la fenêtre contextuelle ne s'affiche. Déplacer la fenêtre ouverte dans une fermeture signifie qu'elle est généralement bloquée par le navigateur.

Je peux comprendre le but d'une fonction de veille si vous devez gérer une exécution synchrone. Les fonctions setInterval et setTimeout créent un thread d'exécution parallèle qui renvoie la séquence d'exécution au programme principal, ce qui est inefficace si vous devez attendre un résultat donné. Bien sûr, on peut utiliser des événements et des gestionnaires, mais dans certains cas, ce n'est pas ce qui est prévu.

Ajout de mes deux bits. J'avais besoin d'une attente occupée à des fins de test. Je ne voulais pas diviser le code car ce serait beaucoup de travail, donc un simple pour l'a fait pour moi.

for (var i=0;i<1000000;i++){                    
     //waiting
  }

Je ne vois aucun inconvénient à faire cela et cela a fait l'affaire pour moi.

Cela peut être fait en utilisant la méthode de sommeil de Java. Je l'ai testé dans FF et IE et il ne verrouille pas l'ordinateur, ne mâche pas les ressources ou ne provoque pas de coups de serveur sans fin. Cela me semble une solution propre.

Vous devez d'abord charger Java sur la page et rendre ses méthodes disponibles. Pour ce faire, je l'ai fait:

<html>
<head>

<script type="text/javascript">

  function load() {
    var appletRef = document.getElementById("app");
    window.java = appletRef.Packages.java;
  } // endfunction

</script>

<body onLoad="load()">

<embed id="app" code="java.applet.Applet" type="application/x-java-applet" MAYSCRIPT="true" width="0" height="0" />

Ensuite, tout ce que vous avez à faire lorsque vous souhaitez une pause indolore dans votre JS est:

java.lang.Thread.sleep(xxx)

Où xxx est le temps en millisecondes. Dans mon cas (à titre de justification), cela faisait partie de l'exécution des commandes back-end dans une très petite entreprise et je devais imprimer une facture qui devait être chargée depuis le serveur. Je l'ai fait en chargeant la facture (en tant que page Web) dans un iFrame puis en imprimant l'iFrame. Bien sûr, j'ai dû attendre que la page soit entièrement chargée avant de pouvoir imprimer, le JS a donc dû s'arrêter. J'ai accompli cela en ayant la page de facture (dans l'iFrame) changer un champ de formulaire caché sur la page parent avec l'événement onLoad. Et le code sur la page parent pour imprimer la facture ressemblait à ceci (pièces non pertinentes coupées pour plus de clarté):

var isReady = eval('document.batchForm.ready');
isReady.value=0;

frames['rpc_frame'].location.href=url;

while (isReady.value==0) {
  java.lang.Thread.sleep(250);
} // endwhile

window.frames['rpc_frame'].focus();
window.frames['rpc_frame'].print();

Ainsi, l'utilisateur appuie sur le bouton, le script charge la page de facture, puis attend, vérifiant chaque quart de seconde pour voir si le chargement de la page de facture, puis ouvre la boîte de dialogue d'impression pour que l'utilisateur l'envoie à l'imprimante. QED.

Beaucoup de réponses ne répondent pas (directement) à la question, et celle-ci non plus ...

Voici mes deux cents (ou fonctions):

Si vous voulez des fonctions moins maladroites que setTimeoutet setInterval, vous pouvez les encapsuler dans des fonctions qui inversent simplement l'ordre des arguments et leur donnent de beaux noms:

function after(ms, fn){ setTimeout(fn, ms); }
function every(ms, fn){ setInterval(fn, ms); }

Versions de CoffeeScript:

after = (ms, fn)-> setTimeout fn, ms
every = (ms, fn)-> setInterval fn, ms

Vous pouvez ensuite les utiliser correctement avec des fonctions anonymes:

after(1000, function(){
    console.log("it's been a second");
    after(1000, function(){
        console.log("it's been another second");
    });
});

Maintenant, il se lit facilement comme "après N millisecondes, ..." (ou "toutes les N millisecondes, ...")

Pour le cas spécifique de vouloir espacer un ensemble d'appels en cours d'exécution par une boucle, vous pouvez utiliser quelque chose comme le code ci-dessous avec prototype. Sans prototype, vous pouvez remplacer la fonction de retard par setTimeout.

function itemHandler(item)
{
    alert(item);
}

var itemSet = ['a','b','c'];

// Each call to itemHandler will execute
// 1 second apart
for(var i=0; i<itemSet.length; i++)
{
    var secondsUntilExecution = i;
    itemHandler.delay(secondsUntilExecution, item)
}

Si vous êtes sur node.js, vous pouvez voir les fibres - une extension C native vers node, une simulation un peu multi-threading.

Il vous permet de faire un réel sleepd'une manière qui bloque l'exécution dans une fibre, mais il n'est pas bloquant dans le thread principal et d'autres fibres.

Voici un exemple fraîchement extrait de leur propre fichier Lisez-moi:

// sleep.js

var Fiber = require('fibers');

function sleep(ms) {
    var fiber = Fiber.current;
    setTimeout(function() {
        fiber.run();
    }, ms);
    Fiber.yield();
}

Fiber(function() {
    console.log('wait... ' + new Date);
    sleep(1000);
    console.log('ok... ' + new Date);
}).run();
console.log('back in main');

- et les résultats sont:

$ node sleep.js
wait... Fri Jan 21 2011 22:42:04 GMT+0900 (JST)
back in main
ok... Fri Jan 21 2011 22:42:05 GMT+0900 (JST)