Qual é a versão JavaScript do sleep ()?

Existe uma maneira melhor de projetar um sleepem JavaScript do que a seguinte pausecompfunção ( extraída daqui )?

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

Esta não é uma duplicata do sono em JavaScript - atraso entre ações ; Eu quero um sono real no meio de uma função, e não um atraso antes que um pedaço de código seja executado.

Atualização 2017 - 2019

Desde 2009, quando essa pergunta foi feita, o JavaScript evoluiu significativamente. Todas as outras respostas agora estão obsoletas ou excessivamente complicadas. Aqui está a melhor prática atual:

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();

É isso. await sleep(<duration>).

Ou como uma linha:

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

Observe que,

1. awaitsó pode ser executado em funções prefixadas com a asyncpalavra - chave ou no nível superior do seu script em alguns ambientes (por exemplo, o console do Chrome DevTools ou o Runkit).
2. awaitpausa apenas a asyncfunção atual

Dois novos recursos de JavaScript ajudaram a escrever essa função "sleep":

• Promises, um recurso nativo do ES2015 (também conhecido como ES6). Também usamos funções de seta na definição da função de suspensão.
• O async/awaitrecurso permite que o código aguarde explicitamente a promessa de liquidação (resolução ou rejeição).

Compatibilidade

• promessas são suportadas no nó v0.12 + e amplamente suportadas em navegadores , exceto no IE
• async/ awaitdesembarcou na V8 e foi ativado por padrão desde o Chrome 55 (lançado em dezembro de 2016)
  • aterrou no nó 7 em outubro de 2016
  • e também desembarcou no Firefox Nightly em novembro de 2016

Se por algum motivo estranho você estiver usando Node mais velho do que 7 (que chegou a final da vida ), ou são alvo navegadores antigos, async/ awaitainda pode ser utilizada através de Babel (uma ferramenta que irá transpile JavaScript + novas funcionalidades em bom e velho JavaScript) , com o transform-async-to-generatorplugin.

(Veja a resposta atualizada para 2016 )

Eu acho perfeitamente razoável querer executar uma ação, esperar e depois executar outra ação. Se você está acostumado a escrever em idiomas multithread, provavelmente terá a idéia de executar a execução por um período de tempo definido até que o thread seja ativado.

O problema aqui é que o JavaScript é um modelo baseado em evento de thread único. Enquanto, em um caso específico, pode ser bom esperar o mecanismo inteiro por alguns segundos; em geral, é uma prática ruim. Suponha que eu quisesse usar suas funções enquanto escrevia minhas próprias? Quando chamei seu método, meus métodos congelariam. Se o JavaScript puder, de alguma forma, preservar o contexto de execução da sua função, armazene-o em algum lugar, traga-o de volta e continue mais tarde, então o sono pode acontecer, mas isso seria basicamente o encadeamento.

Portanto, você está praticamente preso ao que os outros sugeriram - precisará dividir seu código em várias funções.

Sua pergunta é um pouco de uma escolha falsa, então. Não há como dormir da maneira que você deseja, nem deve buscar a solução sugerida.

Em JavaScript, reescrevo todas as funções para que possam terminar o mais rápido possível. Você deseja que o navegador volte ao controle para que ele possa fazer alterações no seu DOM.

Toda vez que eu queria dormir no meio da minha função, eu refatorava para usar a setTimeout().

Editar

O sono infame, ou atraso, função em qualquer idioma é muito debatido. Alguns dirão que sempre deve haver um sinal ou retorno de chamada para disparar uma determinada funcionalidade, outros argumentarão que às vezes um momento arbitrário de atraso é útil. Eu digo que cada uma delas e uma regra nunca podem ditar nada neste setor.

Escrever uma função de suspensão é simples e ainda mais utilizável com o 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!
});

Somente para debug / dev , eu posto isso se for útil para alguém

Coisas interessantes, no Firebug (e provavelmente em outros consoles js), nada acontece depois de pressionar enter, somente após a duração do sono especificada (...)

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

Exemplo de uso:

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

Eu concordo com os outros pôsteres, um sono agitado é apenas uma má idéia.

No entanto, setTimeout não sustenta a execução, ele executa a próxima linha da função imediatamente após o tempo limite ser SET, não após o tempo limite expirar, para que não realize a mesma tarefa que um sono realizaria.

A maneira de fazer isso é desmembrar sua função nas partes antes e depois.

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

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

Verifique se os nomes das funções ainda descrevem com precisão o que cada peça está fazendo (IE GatherInputThenWait e CheckInput, em vez de funcPart1 e funcPart2)

Editar

Esse método atinge o objetivo de não executar as linhas de código que você decide até APÓS o tempo limite, enquanto ainda retorna o controle ao PC cliente para executar o que quer que esteja na fila.

Editar mais

Como apontado nos comentários, isso absolutamente NÃO FUNCIONA em um loop. Você pode fazer alguns hackers (feios) extravagantes para fazê-lo funcionar em um loop, mas, em geral, isso resultará em um código espaguete desastroso.

Por amor a $ DEITY, por favor, não faça uma função de espera de ocupado. setTimeoute setIntervalfaça tudo o que você precisa.

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

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

A cada intervalo de dois segundos, oculta o texto por um segundo. Isso mostra como usar setInterval e setTimeout para mostrar e ocultar o texto a cada segundo.

Sei que essa é uma pergunta antiga, mas se (como eu) você estiver usando Javascript no Rhino, poderá usar ...

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.
   */
}

Se você estiver usando jQuery, alguém realmente criou um plug-in "delay" que nada mais é do que um wrapper para 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;
};

Você pode usá-lo em uma linha de chamadas de função conforme o esperado:

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

Também procurei a solução do sono (não o código de produção, apenas o dev / tests) e encontrei este artigo:

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

... e aqui está outro link com soluções do lado do cliente: http://www.devcheater.com/

Além disso, quando você estiver ligando alert(), seu código também será pausado, enquanto o alerta for exibido - é preciso encontrar uma maneira de não exibir o alerta, mas obter o mesmo efeito. :)

Aqui está uma solução simples usando um XMLHttpRequest síncrono:

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

conteúdo de sleep.php:

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

Agora chame-o com: sleep (5);

Aqui está. Como o código diz, não seja um desenvolvedor ruim e use isso em sites. É uma função de utilitário de desenvolvimento.

// 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) {}
}

Eu pessoalmente gosto do simples:

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

então:

sleep(2); // Sleeps for 2 seconds

Estou usando o tempo todo para criar um tempo de carregamento falso enquanto cria scripts no P5js

Primeiro:

Defina uma função que você deseja executar assim:

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

Em seguida, planeje sua execução com o método setTimeout:

setTimeout(alertWorld,1000)

Observe duas coisas

• o segundo argumento é o tempo em milissegundos
• como primeiro argumento, você deve passar apenas o nome (referência) da função, sem os parênteses

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

verifique se a função de chamada é assíncrona

verificado e funcionando bem

A melhor solução para fazer as coisas parecerem o que a maioria das pessoas deseja é usar uma função anônima:

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

Provavelmente é o mais próximo que você pode chegar de algo que simplesmente faz o que você deseja.

Observe que, se você precisar de várias dormidas, isso pode ficar feio às pressas e você pode realmente precisar repensar seu design.

Para navegadores, concordo que setTimeout e setInterval são o caminho a percorrer.

Mas para o código do servidor, pode ser necessária uma função de bloqueio (por exemplo, para que você possa efetivamente sincronizar o encadeamento).

Se você estiver usando o node.js e o meteoro, pode ter encontrado as limitações do uso de setTimeout em uma fibra. Aqui está o código para suspensão do servidor.

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');

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

Encapsularia setTimeOut em uma promessa de consistência de código com outras tarefas assíncronas: Demo in Fiddle

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

Usado assim:

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

É fácil lembrar a sintaxe se você costumava usar o Promises.

Atualização de 2019 usando Atomics.wait

Deve funcionar no nó 9.3 ou superior.

Eu precisava de um cronômetro bastante preciso no Node.js e funciona muito bem para isso. No entanto, parece que há um suporte extremamente limitado nos navegadores.

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

Executou alguns benchmarks de timer de 10 segundos.

Com o setTimeout, recebo um erro de até 7000 microssegundos. (7ms)

Com o Atomics, meu erro parece permanecer abaixo de 600 microssegundos. (0.6ms)

Atualização 2020: Resumo

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);
}

dos quais a página do lado do servidor, por exemplo sleep.jsp, se parece

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

A maioria das respostas aqui são equivocadas ou, no mínimo, desatualizadas. Não há razão para o javascript ter que ser único e, de fato, não é. Hoje, todos os navegadores convencionais oferecem suporte a trabalhadores, antes disso, outros tempos de execução de javascript, como Rhino e Node.js, suportavam multithreading.

'Javascript é único encadeado' não é uma resposta válida. Por exemplo, executar uma função de suspensão em um trabalhador não bloqueia nenhum código em execução no encadeamento da interface do usuário.

Em tempos de execução mais recentes que suportam geradores e rendimento, pode-se trazer funcionalidade semelhante à função de suspensão em um único ambiente de encadeamento:

// 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);

Essa imitação do sono é diferente de uma verdadeira função de sono, pois não bloqueia o encadeamento. É simplesmente uma adição à função atual setTimeout do javascript. Esse tipo de funcionalidade foi implementado no Task.js e deve funcionar hoje no Firefox.

Eu pesquisei / pesquisei algumas páginas da web em javascript sleep / wait ... e não há resposta se você quiser que o javascript "execute, atrase, execute" ... o que a maioria das pessoas conseguiu foi: "EXECUTAR, EXECUTAR (inútil coisas), EXECUTAR "ou" EXECUTAR, EXECUTAR + EXECUTAR atrasado "....

Então eu comi alguns hambúrgueres e fiquei pensando ::: aqui está uma solução que funciona ... mas você precisa cortar seus códigos de execução ... ::: sim, eu sei, isso é apenas uma refatoração mais fácil de ler .. . ainda...

//......................................... //Exemplo 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>

// .................................... // example2:

<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>

// ................. exemplo3:

<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>

// .............. example4:

<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;
    }
  }
}

A solução mais curta sem nenhuma dependência:

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

Você não pode dormir assim em JavaScript, ou melhor, não deveria. A execução de um loop sleep ou while fará com que o navegador do usuário seja interrompido até que o loop seja concluído.

Use um cronômetro, conforme especificado no link que você referenciou.

Um cenário em que você pode querer uma função sleep () em vez de usar setTimeout () é se você tiver uma função respondendo a um clique do usuário que acabará por abrir uma nova janela pop-up, ou seja, e você iniciou algum processamento que requer um curto período para concluir antes que o pop-up seja exibido. Mover a janela aberta para um fechamento significa que ela normalmente é bloqueada pelo navegador.

Entendo o objetivo de uma função de suspensão, se você precisar lidar com a execução síncrona. As funções setInterval e setTimeout criam um encadeamento de execução paralelo que retorna a sequência de execução ao programa principal, que é ineficaz se você precisar esperar por um determinado resultado. É claro que se pode usar eventos e manipuladores, mas em alguns casos não é o que se pretende.

Adicionando meus dois bits. Eu precisava de uma espera ocupada para fins de teste. Eu não queria dividir o código, pois isso daria muito trabalho, então é simples fazer isso por mim.

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

Não vejo nenhuma desvantagem em fazer isso e isso fez o truque para mim.

Isso pode ser feito usando o método de suspensão do Java. Eu testei no FF e no IE e ele não bloqueia o computador, mastiga recursos ou causa inúmeros acessos ao servidor. Parece uma solução limpa para mim.

Primeiro, você deve carregar o Java na página e disponibilizar seus métodos. Para fazer isso, eu fiz o seguinte:

<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" />

Então, tudo o que você precisa fazer quando deseja uma pausa indolor no seu JS é:

java.lang.Thread.sleep(xxx)

Onde xxx é o tempo em milissegundos. No meu caso (como justificativa), isso fazia parte do atendimento de pedidos de back-end em uma empresa muito pequena e eu precisava imprimir uma fatura que precisava ser carregada do servidor. Fiz isso carregando a fatura (como uma página da Web) em um iFrame e depois imprimindo o iFrame. Obviamente, tive que esperar até que a página estivesse totalmente carregada para poder imprimir, então o JS teve que fazer uma pausa. Eu consegui isso fazendo com que a página da fatura (no iFrame) alterasse um campo de formulário oculto na página pai com o evento onLoad. E o código na página pai para imprimir a fatura tinha esta aparência (peças irrelevantes cortadas para maior clareza):

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();

Assim, o usuário aperta o botão, o script carrega a página da fatura e aguarda, verificando a cada quarto de segundo se a página da fatura terminou de carregar e, em seguida, aparece a caixa de diálogo de impressão para que o usuário a envie à impressora. QED.

Muitas das respostas não (diretamente) respondem à pergunta, e nem essa ...

Aqui estão meus dois centavos (ou funções):

Se você deseja menos funções desajeitadas que setTimeoute setInterval, pode envolvê-las em funções que apenas invertem a ordem dos argumentos e lhes dão nomes agradáveis:

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

Versões do CoffeeScript:

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

Você pode usá-los perfeitamente com funções anônimas:

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

Agora, lê-se facilmente como "após N milissegundos ..." (ou "a cada N milissegundo ...")

Para o caso específico de querer espaçar um conjunto de chamadas sendo executadas por um loop, você pode usar algo como o código abaixo com o protótipo. Sem protótipo, você pode substituir a função de atraso por 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)
}

Se você estiver no node.js, poderá ver as fibras - uma extensão C nativa para o nó, uma simulação meio de multi-threading.

Ele permite que você faça um real de sleepmaneira a bloquear a execução em uma fibra, mas não bloqueia o encadeamento principal e outras fibras.

Aqui está um exemplo recente de seu próprio leia-me:

// 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');

- e os resultados são:

$ 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)