Estou desenvolvendo um console como script para necessidades pessoais. Eu preciso fazer uma pausa por um longo período de tempo, mas, a partir da minha pesquisa, o node.js não tem como parar conforme necessário. Está ficando difícil ler as informações dos usuários após um período de tempo ... Eu vi alguns códigos por aí, mas acredito que eles precisam ter outro código dentro deles para que funcionem, como:

setTimeout(function() {
}, 3000);

No entanto, eu preciso de tudo após esta linha de código para executar após o período de tempo.

Por exemplo,

//start-of-code
console.log('Welcome to My Console,');
some-wait-code-here-for-ten-seconds..........
console.log('Blah blah blah blah extra-blah');
//endcode. 

Eu também vi coisas como

yield sleep(2000);

Mas o node.js não reconhece isso.

Como posso conseguir essa pausa prolongada?

A melhor maneira de fazer isso é dividir seu código em várias funções, assim:

function function1() {
    // stuff you want to happen right away
    console.log('Welcome to My Console,');
}

function function2() {
    // all the stuff you want to happen after that pause
    console.log('Blah blah blah blah extra-blah');
}

// call the first chunk of code right away
function1();

// call the rest of the code and have it execute after 3 seconds
setTimeout(function2, 3000);

É semelhante à solução do JohnnyHK , mas muito mais simples e fácil de estender.

Uma nova resposta para uma pergunta antiga. Hoje ( janeiro de 2017 junho de 2019) é muito mais fácil. Você pode usar a nova async/awaitsintaxe . Por exemplo:

async function init() {
  console.log(1);
  await sleep(1000);
  console.log(2);
}

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

Para usar async/awaitimediatamente, sem instalar e plug-ins, é necessário usar o nó-v7 ou o nó-v8, usando o --harmonysinalizador

Atualização junho de 2019: Ao usar as versões mais recentes do NodeJS, você pode usá-lo imediatamente. Não há necessidade de fornecer argumentos de linha de comando. Até o Google Chrome o suporta hoje.

Atualização em maio de 2020: em breve você poderá usar a awaitsintaxe fora de uma função assíncrona. No nível superior, como neste exemplo

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

A proposta está no estágio 3 . Você pode usá-lo hoje usando o webpack 5 (alpha),

Mais informações:

• Sinalizador de harmonia em Nodejs: https://nodejs.org/en/docs/es6/
• Toda a versão do NodeJS para download: https://nodejs.org/en/download/releases/

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

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

Coloque o código que você deseja executar após o atraso no setTimeoutretorno de chamada:

console.log('Welcome to My Console,');
setTimeout(function() {
    console.log('Blah blah blah blah extra-blah');
}, 3000);

Esta é uma técnica simples de bloqueio:

var waitTill = new Date(new Date().getTime() + seconds * 1000);
while(waitTill > new Date()){}

Está bloqueando na medida em que nada mais acontecerá no seu script (como retornos de chamada). Mas como esse é um script de console, talvez seja o que você precisa!

No nó 7.6.0 ou superior

O nó suporta a espera nativamente:

const sleep = (waitTimeInMs) => new Promise(resolve => setTimeout(resolve, waitTimeInMs));

se você pode usar funções assíncronas:

await sleep(10000); // sleep for 10 seconds

ou:

sleep(10000).then(() => {
  // This will execute 10 seconds from now
});

Nas versões mais antigas do nó (resposta original)

Eu queria um sono assíncrono que funcionasse no Windows e Linux, sem sobrecarregar minha CPU com um longo loop. Tentei o pacote de suspensão, mas ele não foi instalado na minha caixa do Windows. Acabei usando:

https://www.npmjs.com/package/system-sleep

Para instalá-lo, digite:

npm install system-sleep

No seu código,

var sleep = require('system-sleep');
sleep(10*1000); // sleep for 10 seconds

Funciona como um encanto.

Função de sono simples e elegante usando Javascript moderno

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

Sem dependências, sem retorno de chamada; é isso aí :-)

Considerando o exemplo dado na pergunta, é assim que dormimos entre dois logs do console:

async function main() {
    console.log("Foo");
    await sleep(2000);
    console.log("Bar");
}

main();

A "desvantagem" é que sua função principal agora também precisa ser async. Mas, considerando que você já está escrevendo um código Javascript moderno, provavelmente você está (ou pelo menos deveria estar!) Usando async/ em awaittodo o seu código, então isso realmente não é um problema. Todos os navegadores modernos hoje suportam .

Fornecendo uma pequena visão da sleepfunção para aqueles que não estão acostumados async/awaite operadores de seta gorda, esta é a maneira detalhada de escrevê-la:

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

No entanto, o uso do operador de seta gorda o torna ainda menor (e mais elegante).

Você pode usar este site www.npmjs.com/package/sleep

var sleep = require('sleep');
sleep.sleep(10); // sleep for ten seconds

Essa pergunta é bastante antiga, mas recentemente a V8 adicionou geradores que podem realizar o que o OP solicitou. Geralmente, os geradores são mais fáceis de usar para interações assíncronas com a assistência de uma biblioteca, como suspender ou executar com gen .

Aqui está um exemplo usando o suspend:

suspend(function* () {
    console.log('Welcome to My Console,');
    yield setTimeout(suspend.resume(), 10000); // 10 seconds pass..
    console.log('Blah blah blah blah extra-blah');
})();

Leitura relacionada (por meio de autopromoção desavergonhada): Qual é o grande problema dos geradores? .

No Linux / nodejs, isso funciona para mim:

const spawnSync = require ('child_process'). spawnSync;

var sono = spawnSync ('sono', [1.5]);

Está bloqueando, mas não é um ciclo de espera ocupado.

O tempo especificado é em segundos, mas pode ser uma fração. Não sei se outros sistemas operacionais têm um comando semelhante.

Se você deseja "codificar golfe", você pode fazer uma versão mais curta de algumas das outras respostas aqui:

const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));

Mas, na verdade, a resposta ideal, na minha opinião, é usar a utilbiblioteca do Node e sua promisifyfunção, projetada exatamente para esse tipo de coisa (criando versões baseadas em promessas de coisas não baseadas em promessas anteriormente existentes):

const util = require('util');
const sleep = util.promisify(setTimeout);

Em ambos os casos, você pode pausar simplesmente usando awaitpara chamar sua sleepfunção:

await sleep(1000); // sleep for 1s/1000ms

Recentemente, criei uma abstração mais simples chamada wait.for para chamar funções assíncronas no modo de sincronização (com base nas fibras do nó). Há também uma versão baseada nos próximos Geradores ES6.

https://github.com/luciotato/waitfor

Usando wait.for , você pode chamar qualquer função nodejs assíncrona padrão, como se fosse uma função de sincronização, sem bloquear o loop de eventos do nó.

Você pode codificar sequencialmente quando precisar, o que é (suponho) perfeito para simplificar seus scripts para uso pessoal.

usando wait.for, seu código será:

require('waitfor')

..in a fiber..
//start-of-code
console.log('Welcome to My Console,');
wait.miliseconds(10*1000); //defined in waitfor/paralell-tests.js - DOES NOT BLOCK
console.log('Blah blah blah blah extra-blah');
//endcode. 

Também qualquer função assíncrona pode ser chamada no modo Sincronizar . Veja os exemplos.

Como o mecanismo javascript (v8) executa o código com base na sequência de eventos na fila de eventos, não é rigoroso que o javascript acione exatamente a execução após o tempo especificado. Ou seja, quando você define alguns segundos para executar o código posteriormente, o código de acionamento é puramente baseado na sequência na fila de eventos. Portanto, disparar a execução do código pode levar mais do que o tempo especificado.

Então o Node.js segue,

process.nextTick()

para executar o código posteriormente, em vez de setTimeout (). Por exemplo,

process.nextTick(function(){
    console.log("This will be printed later");
});

Com o ES6 suportando Promises, podemos usá-los sem nenhum auxílio de terceiros.

const sleep = (seconds) => {
    return new Promise((resolve, reject) => {
        setTimeout(resolve, (seconds * 1000));
    });
};

// We are not using `reject` anywhere, but it is good to
// stick to standard signature.

Em seguida, use-o assim:

const waitThenDo(howLong, doWhat) => {
    return sleep(howLong).then(doWhat);
};

Observe que a doWhatfunção se torna o resolveretorno de chamada dentro do new Promise(...).

Observe também que isso é sono ASSÍNCRONO. Não bloqueia o loop de eventos. Se você precisar bloquear o sono, use esta biblioteca que realiza o bloqueio do sono com a ajuda de ligações do C ++. (Embora a necessidade de um sono bloqueador no Node como ambientes assíncronos seja rara.)

https://github.com/erikdubbelboer/node-sleep

let co = require('co');
const sleep = ms => new Promise(res => setTimeout(res, ms));

co(function*() {
    console.log('Welcome to My Console,');
    yield sleep(3000);
    console.log('Blah blah blah blah extra-blah');
});

Este código acima é o efeito colateral do problema do inferno de retorno de chamada assíncrona do Javascript. Esta é também a razão pela qual acho que faz do Javascript uma linguagem útil no back-end. Na verdade, esta é a melhoria mais emocionante introduzida no Javascript moderno na minha opinião. Para entender completamente como ele funciona, como o gerador funciona precisa ser totalmente compreendido. A functionpalavra-chave seguida por a *é chamada de função geradora em Javascript moderno. O pacote npm coforneceu uma função runner para executar um gerador.

Essencialmente, a função gerador forneceu uma maneira de pausar a execução de uma função com a yieldpalavra - chave, ao mesmo tempo, yieldem uma função geradora, permitindo a troca de informações entre o gerador e o chamador. Isso forneceu um mecanismo para o chamador extrair dados de uma promisechamada assíncrona e passar os dados resolvidos de volta ao gerador. Efetivamente, ele faz uma chamada assíncrona síncrona.

Este é um módulo com formato moment.js, com base na abordagem de bloqueio sujo sugerida por @ atlex2 . Use isso apenas para testes .

const moment = require('moment');

let sleep = (secondsToSleep = 1) => {
    let sleepUntill = moment().add(secondsToSleep, 'seconds');
    while(moment().isBefore(sleepUntill)) { /* block the process */ }
}

module.exports = sleep;

Se você apenas precisar suspender para fins de teste, a execução atual do encadeamento tente o seguinte:

function longExecFunc(callback, count) {

    for (var j = 0; j < count; j++) {
        for (var i = 1; i < (1 << 30); i++) {
            var q = Math.sqrt(1 << 30);
        }
    }
    callback();
}
longExecFunc(() => { console.log('done!')}, 5); //5, 6 ... whatever. Higher -- longer

simples, vamos esperar por 5 segundos para que algum evento aconteça (que seria indicado pela variável concluída configurada como true em outro lugar no código) ou quando o tempo limite expirar, verificaremos a cada 100 ms

    var timeout=5000; //will wait for 5 seconds or untildone
    var scope = this; //bind this to scope variable
    (function() {
        if (timeout<=0 || scope.done) //timeout expired or done
        {
            scope.callback();//some function to call after we are done
        }
        else
        {
            setTimeout(arguments.callee,100) //call itself again until done
            timeout -= 100;
        }
    })();

Para algumas pessoas, a resposta aceita não está funcionando, encontrei esta outra resposta e está funcionando para mim: Como posso passar um parâmetro para um retorno de chamada setTimeout ()?

var hello = "Hello World";
setTimeout(alert, 1000, hello); 

'olá' é o parâmetro que está sendo passado, você pode passar todos os parâmetros após o tempo limite. Obrigado a @Fabio Phms pela resposta.

Em vez de fazer todos esses setTimeout, sleep e muitas outras coisas, é melhor usar

const delay = require('delay');
await delay(2000); // will wait for 2 seconds before executing next line of code

As outras respostas são ótimas, mas pensei em usar um tato diferente.

Se tudo o que você está realmente procurando é diminuir a velocidade de um arquivo específico no linux:

 rm slowfile; mkfifo slowfile; perl -e 'select STDOUT; $| = 1; while(<>) {print $_; sleep(1) if (($ii++ % 5) == 0); }' myfile > slowfile  &

nó myprog slowfile

Isso durará 1 segundo a cada cinco linhas. O programa do nó será tão lento quanto o gravador. Se estiver fazendo outras coisas, eles continuarão na velocidade normal.

O mkfifo cria um tubo primeiro a entrar, primeiro a sair. É o que faz isso funcionar. A linha perl escreverá tão rápido quanto você desejar. O $ | = 1 diz não armazenar em buffer a saída.

Eu montei, depois de ler as respostas nesta pergunta, uma função simples que também pode fazer um retorno de chamada, se você precisar:

function waitFor(ms, cb) {
  var waitTill = new Date(new Date().getTime() + ms);
  while(waitTill > new Date()){};
  if (cb) {
    cb()
  } else {
   return true
  }
}

Para mais informações sobre

yield sleep(2000); 

você deve verificar o Redux-Saga . Mas é específico para sua escolha do Redux como sua estrutura de modelo (embora estritamente não seja necessário).