Sto sviluppando una console come script per esigenze personali. Devo essere in grado di mettere in pausa per un lungo periodo di tempo, ma, dalla mia ricerca, node.js non ha modo di fermarsi come richiesto. Sta diventando difficile leggere le informazioni degli utenti dopo un certo periodo di tempo ... Ho visto del codice là fuori, ma credo che debbano avere un altro codice al loro interno per poter funzionare come:

setTimeout(function() {
}, 3000);

Tuttavia, ho bisogno di tutto dopo questa riga di codice per eseguire dopo il periodo di tempo.

Per esempio,

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

Ho visto anche cose del genere

yield sleep(2000);

Ma node.js non lo riconosce.

Come posso ottenere questa pausa prolungata?

Il modo migliore per farlo è suddividere il codice in più funzioni, in questo modo:

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

È simile alla soluzione di JohnnyHK , ma molto più ordinata e più facile da estendere.

Una nuova risposta a una vecchia domanda. Oggi ( gennaio 2017 giugno 2019) è molto più semplice. È possibile utilizzare la nuova async/awaitsintassi . Per esempio:

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

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

Per usare async/awaitout of the box senza installazione e plugin, devi usare node-v7 o node-v8, usando il --harmonyflag.

Aggiornamento giugno 2019: utilizzando le ultime versioni di NodeJS è possibile utilizzarlo immediatamente. Non è necessario fornire argomenti da riga di comando. Anche Google Chrome lo supporta oggi.

Aggiornamento maggio 2020: Presto sarai in grado di utilizzare la awaitsintassi al di fuori di una funzione asincrona. Al livello più alto come in questo esempio

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

La proposta è nella fase 3 . Puoi usarlo oggi usando webpack 5 (alpha),

Ulteriori informazioni:

• Bandiera Harmony in Nodejs: https://nodejs.org/en/docs/es6/
• Tutte le versioni di NodeJS da scaricare: https://nodejs.org/en/download/releases/

La soluzione più breve senza dipendenze:

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

Inserire il codice che si desidera eseguire dopo il ritardo nel setTimeoutcallback:

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

Questa è una semplice tecnica di blocco:

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

Si blocca nella misura in cui non accadrà nient'altro nella tua sceneggiatura (come i callback). Ma poiché questo è uno script per console, forse è quello che ti serve!

Sul nodo 7.6.0 o successivo

Il nodo supporta l'attesa nativa:

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

quindi se puoi usare le funzioni asincrone:

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

o:

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

Nelle versioni precedenti del nodo (risposta originale)

Volevo un sonno asincrono che funzionasse in Windows e Linux, senza eseguire il hogging della mia CPU con un lungo ciclo. Ho provato il pacchetto sleep ma non si installava sul mio box di Windows. Ho finito per usare:

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

Per installarlo, digitare:

npm install system-sleep

Nel tuo codice,

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

Funziona come un fascino.

Funzione sleep semplice ed elegante che utilizza Javascript moderno

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

Nessuna dipendenza, nessun inferno di richiamata; questo è tutto :-)

Considerando l'esempio fornito nella domanda, ecco come dormire tra due registri della console:

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

main();

Lo "svantaggio" è che ora deve essere asyncanche la tua funzione principale . Ma, considerando che stai già scrivendo il moderno codice Javascript, probabilmente stai (o almeno dovresti!) Usare async/ awaittutto il tuo codice, quindi questo non è davvero un problema. Tutti i browser moderni oggi lo supportano .

Fornire un po 'di comprensione della sleepfunzione per coloro che non sono abituati async/awaite per gli operatori con le frecce grasse, questo è il modo dettagliato di scriverlo:

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

L'uso dell'operatore freccia grassa, tuttavia, lo rende ancora più piccolo (e più elegante).

Puoi usare questo www.npmjs.com/package/sleep

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

Questa domanda è piuttosto vecchia, ma recentemente V8 ha aggiunto generatori che possono realizzare ciò che l'OP ha richiesto. I generatori sono generalmente più facili da usare per le interazioni asincrone con l'assistenza di una libreria come suspend o gen-run .

Ecco un esempio usando 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');
})();

Lettura correlata (attraverso l'autopromozione spudorata): qual è il grosso problema con i generatori? .

Su Linux / nodejs questo funziona per me:

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

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

Si sta bloccando, ma non è un circuito di attesa occupato.

Il tempo specificato è in secondi ma può essere una frazione. Non so se altri SO abbiano un comando simile.

Se vuoi "programmare il golf" puoi fare una versione più breve di alcune delle altre risposte qui:

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

Ma davvero la risposta ideale secondo me è usare Node util libreria e la sua promisifyfunzione, che è progettata proprio per questo tipo di cose (fare versioni basate su promesse di cose non basate su promesse precedentemente esistenti):

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

In entrambi i casi puoi quindi mettere in pausa semplicemente usando awaitper chiamare la tua sleepfunzione:

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

Di recente ho creato un'astrazione più semplice chiamata wait.for per chiamare le funzioni asincrone in modalità di sincronizzazione (basata su nodi-fibre). Esiste anche una versione basata sui prossimi generatori ES6.

https://github.com/luciotato/waitfor

utilizzando wait.for , puoi chiamare qualsiasi funzione asincrona nodejs standard, come se fosse una funzione di sincronizzazione, senza bloccare il loop degli eventi del nodo.

Puoi programmare in sequenza quando ne hai bisogno, il che è (suppongo) perfetto per semplificare i tuoi script per uso personale.

usando wait.for il tuo codice sarà:

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. 

Inoltre, qualsiasi funzione asincrona può essere chiamata in modalità Sync . Controlla gli esempi.

Poiché javascript engine (v8) esegue il codice in base alla sequenza di eventi nella coda degli eventi, non è rigoroso che javascript avvii esattamente l'esecuzione dopo il tempo specificato. Cioè, quando si impostano alcuni secondi per eseguire il codice in un secondo momento, l'attivazione del codice è puramente basata sulla sequenza nella coda degli eventi. Pertanto l'attivazione dell'esecuzione del codice può richiedere più del tempo specificato.

Quindi Node.js segue,

process.nextTick()

per eseguire il codice in un secondo momento, invece setTimeout (). Per esempio,

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

Con ES6 di supporto Promise, possiamo usarli senza alcun aiuto di terze parti.

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.

Quindi usalo in questo modo:

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

Si noti che la doWhatfunzione diventa il resolvecallback all'interno di new Promise(...).

Si noti inoltre che questo è sonno ASINCRONO. Non blocca il loop degli eventi. Se è necessario bloccare la sospensione, utilizzare questa libreria che realizza il blocco della sospensione con l'aiuto dei collegamenti C ++. (Sebbene la necessità di bloccare il sonno in Node come gli ambienti asincroni sia 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');
});

Questo codice sopra è l'effetto collaterale della risoluzione del problema infernale di callback asincrono di Javascript. Questo è anche il motivo per cui penso che renda Javascript un linguaggio utile nel backend. In realtà questo è il miglioramento più entusiasmante introdotto nel Javascript moderno secondo me. Per comprendere appieno come funziona, è necessario comprendere appieno come funziona il generatore. La functionparola chiave seguita da a *è chiamata funzione generatore nel moderno Javascript. Il pacchetto npm ha cofornito una funzione runner per eseguire un generatore.

Essenzialmente la funzione generatore ha fornito un modo per mettere in pausa l'esecuzione di una funzione con yieldparola chiave, allo stesso tempo, yieldin una funzione generatore ha reso possibile lo scambio di informazioni tra il generatore e il chiamante. Ciò ha fornito un meccanismo per il chiamante per estrarre i dati da una promisechiamata asincrona e restituire i dati risolti al generatore. In effetti, sincronizza una chiamata asincrona.

Questo è un modulo aromatizzato moment.js basato sull'approccio di blocco sporco suggerito da @ atlex2 . Utilizzare questo solo per i test .

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 devi solo sospendere a scopo di test l'attuale esecuzione del thread prova questo:

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

semplice aspetteremo per 5 secondi che si verifichi un evento (che sarebbe indicato dalla variabile done impostata su true da qualche altra parte nel codice) o quando scade il timeout che verificheremo ogni 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;
        }
    })();

Per alcune persone, la risposta accettata non funziona, ho trovato quest'altra risposta e funziona per me: come posso passare un parametro a un callback setTimeout ()?

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

'ciao' è il parametro che viene passato, è possibile passare tutti i parametri dopo il timeout. Grazie a @Fabio Phms per la risposta.

Invece di fare tutto questo setTimeout, sleep e molte altre cose, è meglio usare

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

Le altre risposte sono fantastiche, ma ho pensato di prendere un tatto diverso.

Se tutto ciò che stai veramente cercando è rallentare un file specifico in Linux:

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

nodo myprog slowfile

Questo dormirà 1 secondo ogni cinque righe. Il programma del nodo andrà lento come lo scrittore. Se sta facendo altre cose, continueranno a velocità normale.

Mkfifo crea una pipe first-in-first-out. È ciò che rende questo lavoro. La riga perl scriverà velocemente quanto vuoi. $ | = 1 dice di non bufferizzare l'output.

Metto insieme, dopo aver letto le risposte in questa domanda, una semplice funzione che può anche fare una richiamata, se ne hai bisogno:

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

Per maggiori informazioni su

yield sleep(2000); 

dovresti controllare Redux-Saga . Ma è specifico per la scelta di Redux come framework del modello (anche se strettamente non necessario).