Ich entwickle ein konsolenähnliches Skript für persönliche Bedürfnisse. Ich muss in der Lage sein, längere Zeit zu pausieren, aber nach meinen Recherchen kann node.js nicht wie erforderlich anhalten. Es wird nach einiger Zeit schwierig, Benutzerinformationen zu lesen ... Ich habe dort draußen Code gesehen, aber ich glaube, sie müssen anderen Code in sich haben, damit sie funktionieren, wie zum Beispiel:

setTimeout(function() {
}, 3000);

Ich brauche jedoch alles nach dieser Codezeile, um nach Ablauf der Zeit ausgeführt zu werden.

Zum Beispiel,

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

Ich habe auch Dinge wie gesehen

yield sleep(2000);

Aber node.js erkennt dies nicht.

Wie kann ich diese längere Pause erreichen?

Der beste Weg, dies zu tun, besteht darin, Ihren Code in mehrere Funktionen zu unterteilen, wie folgt:

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

Es ähnelt der Lösung von JohnnyHK , ist jedoch viel übersichtlicher und einfacher zu erweitern.

Eine neue Antwort auf eine alte Frage. Heute ( Januar 2017, Juni 2019) ist es viel einfacher. Sie können die neue async/awaitSyntax verwenden . Zum Beispiel:

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

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

Für die async/awaitsofortige Verwendung ohne Installation und Plugins müssen Sie Node-v7 oder Node-v8 mit dem --harmonyFlag verwenden.

Update Juni 2019: Mit den neuesten Versionen von NodeJS können Sie es sofort verwenden. Es müssen keine Befehlszeilenargumente angegeben werden. Sogar Google Chrome unterstützt es heute.

Update Mai 2020: In Kürze können Sie die awaitSyntax auch außerhalb einer asynchronen Funktion verwenden. In der obersten Ebene wie in diesem Beispiel

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

Der Vorschlag befindet sich in Phase 3 . Sie können es heute mit Webpack 5 (Alpha) verwenden.

Mehr Info:

• Harmony Flag in Nodejs: https://nodejs.org/en/docs/es6/
• Alle NodeJS-Versionen zum Download: https://nodejs.org/en/download/releases/

Die kürzeste Lösung ohne Abhängigkeiten:

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

Fügen Sie den Code, den Sie nach der Verzögerung ausführen möchten, in den setTimeoutRückruf ein:

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

Dies ist eine einfache Blockiertechnik:

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

Es wird blockiert, sofern in Ihrem Skript nichts anderes passiert (wie Rückrufe). Aber da dies ein Konsolenskript ist, ist es vielleicht das, was Sie brauchen!

Auf Knoten 7.6.0 oder höher

Der Knoten unterstützt das native Warten:

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

Wenn Sie dann asynchrone Funktionen verwenden können:

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

oder:

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

Auf älteren Node-Versionen (ursprüngliche Antwort)

Ich wollte einen asynchronen Ruhezustand, der unter Windows und Linux funktioniert, ohne meine CPU mit einer langen while-Schleife zu belasten. Ich habe das Schlafpaket ausprobiert, es wurde jedoch nicht auf meiner Windows-Box installiert. Am Ende habe ich verwendet:

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

Geben Sie zum Installieren Folgendes ein:

npm install system-sleep

In Ihrem Code

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

Klappt wunderbar.

Einfache und elegante Schlaffunktion mit modernem Javascript

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

Keine Abhängigkeiten, keine Rückrufhölle; das ist es :-)

In Anbetracht des in der Frage angegebenen Beispiels würden wir auf folgende Weise zwischen zwei Konsolenprotokollen schlafen:

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

main();

Der "Nachteil" ist, dass Ihre Hauptfunktion jetzt auch sein muss async. Aber, wenn man bedenken Sie bereits modernen Javascript - Code schreiben, sind Sie wahrscheinlich (oder zumindest sollte es sein!) Mit async/ am awaitganzen Code, so ist dies nicht wirklich ein Problem. Alle modernen Browser unterstützen dies heute.

Dies ist die ausführliche Schreibweise, um einen kleinen Einblick in die sleepFunktion für diejenigen zu geben, die nicht daran gewöhnt sind, async/awaitund Fettpfeiloperatoren:

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

Die Verwendung des Fettpfeil-Operators macht ihn jedoch noch kleiner (und eleganter).

Sie können diese www.npmjs.com/package/sleep verwenden

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

Diese Frage ist ziemlich alt, aber kürzlich hat V8 Generatoren hinzugefügt, die das erreichen können, was das OP angefordert hat. Generatoren sind im Allgemeinen am einfachsten für asynchrone Interaktionen mit Hilfe einer Bibliothek wie Suspend oder Gen-Run zu verwenden .

Hier ist ein Beispiel mit 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');
})();

Verwandte Lektüre (durch schamlose Eigenwerbung): Was ist die große Sache mit Generatoren? .

Unter Linux / nodejs funktioniert das bei mir:

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

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

Es blockiert, ist aber keine ausgelastete Warteschleife.

Die von Ihnen angegebene Zeit ist in Sekunden angegeben, kann jedoch ein Bruchteil sein. Ich weiß nicht, ob andere Betriebssysteme einen ähnlichen Befehl haben.

Wenn Sie Golf "codieren" möchten, können Sie hier eine kürzere Version einiger anderer Antworten erstellen:

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

Aber meiner Meinung nach ist die ideale Antwort die Verwendung der Node- utilBibliothek und ihrer promisifyFunktion, die genau für diese Art von Dingen entwickelt wurde (Versprechensbasierte Versionen von zuvor existierenden, nicht auf Versprechungen basierenden Dingen):

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

In beiden Fällen können Sie dann einfach anhalten, indem Sie awaitIhre sleepFunktion aufrufen :

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

Ich habe kürzlich eine einfachere Abstraktion namens wait.for erstellt , um asynchrone Funktionen im Synchronisationsmodus (basierend auf Knotenfasern) aufzurufen. Es gibt auch eine Version, die auf kommenden ES6-Generatoren basiert.

https://github.com/luciotato/waitfor

Mit wait.for können Sie jede asynchrone Standardfunktion von nodejs aufrufen, als wäre es eine Synchronisierungsfunktion, ohne die Ereignisschleife des Knotens zu blockieren.

Sie können bei Bedarf nacheinander codieren, was (ich vermute) perfekt ist, um Ihre Skripte für den persönlichen Gebrauch zu vereinfachen.

Verwenden Sie wait.for Ihr Code lautet :

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. 

Auch jede Async-Funktion kann im Sync- Modus aufgerufen werden. Überprüfen Sie die Beispiele.

Da die Javascript-Engine (v8) Code basierend auf der Abfolge von Ereignissen in der Ereigniswarteschlange ausführt, gibt es keine Vorgabe, dass Javascript die Ausführung genau nach dem angegebenen Zeitpunkt auslöst. Wenn Sie also einige Sekunden festlegen, um den Code später auszuführen, basiert das Auslösen des Codes ausschließlich auf der Reihenfolge in der Ereigniswarteschlange. Das Auslösen der Codeausführung kann daher länger als angegeben dauern.

Also folgt Node.js,

process.nextTick()

um den Code später auszuführen, setzen Sie stattdessen setTimeout (). Zum Beispiel,

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

Mit ES6-Unterstützung Promisekönnen wir sie ohne fremde Hilfe verwenden.

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.

Dann benutze es so:

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

Beachten Sie, dass die doWhatFunktion zum resolveRückruf innerhalb der wird new Promise(...).

Beachten Sie auch, dass dies ASYNCHRONER Schlaf ist. Die Ereignisschleife wird nicht blockiert. Wenn Sie den Schlaf blockieren müssen, verwenden Sie diese Bibliothek, die mithilfe von C ++ - Bindungen den Block blockiert. (Obwohl die Notwendigkeit eines blockierenden Schlafes in Node-ähnlichen asynchronen Umgebungen selten ist.)

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

Dieser Code oben ist der Nebeneffekt der Lösung des Problems der asynchronen Rückruf-Hölle von Javascript. Dies ist auch der Grund, warum ich denke, dass Javascript eine nützliche Sprache im Backend ist. Tatsächlich ist dies meiner Meinung nach die aufregendste Verbesserung des modernen Javascript. Um vollständig zu verstehen, wie es funktioniert, muss die Funktionsweise des Generators vollständig verstanden werden. Das functionSchlüsselwort gefolgt von a *wird im modernen Javascript als Generatorfunktion bezeichnet. Das npm-Paket cobot eine Runner-Funktion zum Betreiben eines Generators.

Im Wesentlichen bot die Generatorfunktion eine Möglichkeit, die Ausführung einer Funktion mit einem yieldSchlüsselwort zu unterbrechen, während gleichzeitig yieldeine Generatorfunktion den Informationsaustausch zwischen dem Generator und dem Aufrufer ermöglichte. Dies stellte einen promiseAufruf für den Aufrufer bereit, Daten aus einem asynchronen Aufruf zu extrahieren und die aufgelösten Daten an den Generator zurückzugeben. Tatsächlich wird ein asynchroner Anruf synchronisiert.

Dies ist ein Modul mit moment.js-Geschmack, das auf dem von @ atlex2 vorgeschlagenen Dirty-Blocking-Ansatz basiert . Verwenden Sie dies nur zum Testen .

const moment = require('moment');

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

module.exports = sleep;

Wenn Sie die aktuelle Thread-Ausführung nur zu Testzwecken anhalten müssen, versuchen Sie Folgendes:

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

Einfach gesagt, wir werden 5 Sekunden warten, bis ein Ereignis eintritt (dies wird durch die Variable done angezeigt, die an einer anderen Stelle im Code auf true gesetzt ist) oder wenn das Timeout abläuft, werden wir alle 100 ms überprüfen

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

Bei einigen Personen funktioniert die akzeptierte Antwort nicht. Ich habe diese andere Antwort gefunden und sie funktioniert bei mir: Wie kann ich einen Parameter an einen setTimeout () - Rückruf übergeben?

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

'Hallo' ist der Parameter, der übergeben wird. Sie können alle Parameter nach Ablauf der Zeitüberschreitung übergeben. Vielen Dank an @Fabio Phms für die Antwort.

Anstatt all diese setTimeout-, Schlaf- und viele andere Dinge zu tun, ist es besser, sie zu verwenden

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

Die anderen Antworten sind großartig, aber ich dachte, ich würde einen anderen Takt wählen.

Wenn alles, was Sie wirklich suchen, darin besteht, eine bestimmte Datei unter Linux zu verlangsamen:

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

Knoten myprog slowfile

Dies wird alle fünf Zeilen 1 Sekunde lang schlafen. Das Knotenprogramm wird so langsam wie der Writer. Wenn es andere Dinge tut, werden sie mit normaler Geschwindigkeit fortgesetzt.

Das mkfifo erstellt eine First-In-First-Out-Pipe. Das macht diese Arbeit aus. Die Perl-Zeile schreibt so schnell, wie Sie möchten. Das $ | = 1 sagt, dass die Ausgabe nicht gepuffert werden soll.

Nachdem ich die Antworten in dieser Frage gelesen habe, habe ich eine einfache Funktion zusammengestellt, die bei Bedarf auch einen Rückruf durchführen kann:

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

Für weitere Informationen über

yield sleep(2000); 

Sie sollten Redux-Saga überprüfen . Es ist jedoch spezifisch für Ihre Wahl von Redux als Modell-Framework (obwohl dies unbedingt nicht erforderlich ist).