Coloque o código que deseja executar após o atraso no callback setTimeout:

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

async function init(){
   console.log(1)
   await sleep(1000)
   console.log(2)
}
function sleep(ms){
    return new Promise(resolve=>{
        setTimeout(resolve,ms)
    })
}

• Bandeira da harmonia em Notejs: https://nodejs.org/en/docs/es6/
• Todas as versões do NodeJS para download: https://nodejs.org/en/download/releases/

Esta é uma técnica de bloqueio simples:

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

É Bloqueio {[[6]} na medida em que nada mais vai acontecer no seu script (como callbacks). Mas como este é um script de console, talvez seja o que você precisa!

Pode usar este www.npmjs.com/package/sleep

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

Esta questão é bastante antiga, mas recentemente o V8 adicionou geradores que podem realizar o que a operação pediu. Os geradores são geralmente mais fáceis de usar nas interações de async com a assistência de uma biblioteca como suspender ou Gen-run.

Aqui está um exemplo usando suspender:

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

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

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

Sem dependências, sem inferno de retorno; é isso: -)

Considerando o exemplo dado na pergunta, é assim que vamos esperar entre dois registos de consola:

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

main();

A "desvantagem" é que a sua função principal também tem de ser async. Mas, considerando que você já está escrevendo código Javascript moderno, você deve estar usando async/await em todo o seu código, então isto não é um problema. Todo os navegadores modernos apoiam-no.

Dando uma pequena visão sobre a função sleep para aqueles que não estão acostumados a async/await, Você também poderia escrevê-la assim:

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

A solução mais curta sem dependências:

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

Https://github.com/luciotato/waitfor

Usando Espere.para , você pode chamar qualquer função normal nodejs async, como se fosse uma função de sincronização, sem bloquear o loop de eventos do nó.

Usando Espere.para o 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 async pode ser chamada no modo Sync. Veja os exemplos.

No Linux / nodejs isto funciona para mim:

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

Var sleep = spawnSync ('sleep', [1.5]);

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

O tempo que indica é em segundos, mas pode ser uma fracção. Não sei se os outros SO têm um comando semelhante.

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

Para o instalar, escreva:

npm install system-sleep

No seu código,

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

Se você quiser "code golf" você pode fazer uma versão mais curta de algumas das outras respostas aqui:

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

Mas realmente a resposta ideal na minha opinião é usar a biblioteca do Node util e a sua função promisify, que é desenhada para exactamente este tipo de coisa (fazendo versões baseadas em promessas de coisas anteriormente existentes não baseadas em promessas):

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

Em qualquer dos casos, pode então fazer uma pausa simplesmente usando await para chamar a sua função sleep:

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

Uma vez que, javascript engine (v8) executa código baseado na sequência de eventos na fila de eventos, não há nenhum estrito que javascript exatamente despoleta a execução após a hora especificada. Isto é, quando você definir alguns segundos para executar o código mais tarde, o código de ativação é puramente base na sequência na fila de eventos. Assim, desencadear a execução do código pode demorar mais do que o tempo especificado.

So Node.js follows,

process.nextTick()

Para executar o código mais tarde em vez de setTimeout (). Por exemplo,

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

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.

Então usa - o assim:

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

Note que a função doWhat torna-se a resposta resolve dentro do new Promise(...).

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 da resolução do problema assíncrono do inferno de callback do Javascript. Esta é também a razão que eu acho que faz Javascript uma linguagem útil na infra-estrutura. Na verdade, esta é a melhoria mais emocionante introduzida ao Javascript moderno na minha opinião. Para entender completamente como funciona, como o gerador funciona precisa ser totalmente compreendido. A palavra-chave function seguida por uma * é chamada de função gerador em Javascript moderno. O pacote npm co forneceu uma função de corredor para executar um gerador.

Essencialmente a função do gerador forneceu uma forma de pausar a execução de uma função com yield palavra-chave, ao mesmo tempo, yield numa função do gerador tornou possível a troca de informações entre o interior do gerador e o chamador. Isto forneceu um mecanismo para a pessoa que ligou extrair dados de uma chamada assíncrona e passar os dados resolvidos de volta para o gerador. Efectivamente, faz uma chamada assíncrona Sincrono.

Se só precisa de suspender para fins de teste, a execução actual do tópico tente isto:

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 aguardar 5 segundos para algum evento acontecer (que seria indicado pelo feito variável definida como true em algum outro lugar do código) ou quando o tempo limite expira que iremos verificar cada 100ms

    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 aceite não está a funcionar, encontrei esta outra resposta e está a funcionar para mim: Como posso passar um parâmetro a uma chamada de setTimeout ()?

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

'hello' é 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.

Instalar com npm install readline-sync

var readlineSync = require('readline-sync');
while(true) {
  var input = readlineSync.question("What is your input?");
  if(input === 'exit') {
    process.exit();
  } else {
    console.log("Your input was " + input);
  }
}

Talvez não seja a melhor prática, mas faz o trabalho para mim

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 tudo o que realmente procura é abrandar um ficheiro 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

O mkfifo cria um tubo de primeira entrada-primeira saída. É o que faz isto funcionar. A linha perl irá escrever tão rápido quanto você querer. O $|=1 diz para não amortecer a saída.

Para mais informações sobre

yield sleep(2000); 

Devias verificar Redux-Saga. Mas é específico para a sua escolha de Redux como seu modelo framework (embora estritamente não necessário).

Eu juntei, depois de ter lido as respostas nesta pergunta, uma função simples que também pode fazer um callback, se você precisar disso:

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