mettez le code que vous voulez exécuter après le délai dans le setTimeout callback:

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

Une nouvelle réponse à une vieille question. Aujourd'hui (Jan 2017) c'est beaucoup plus facile. Vous pouvez utiliser la nouvelle "syntaxe async/await . Par exemple:

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

• Harmonie du Pavillon en Nodejs: https://nodejs.org/en/docs/es6/
• toute la Version NodeJS à télécharger: https://nodejs.org/en/download/releases/

c'est une technique de blocage simple:

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

c'est blocage dans la mesure où rien d'autre n'arrivera dans votre script (comme des callbacks). Mais puisque c'est un script de console, peut-être que c'est ce dont vous avez besoin!

vous pouvez utiliser ce www.npmjs.com/package/sleep

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

cette question est assez ancienne, mais récemment V8 a ajouté des générateurs qui peuvent accomplir ce que L'OP a demandé. Les générateurs sont généralement plus faciles à utiliser pour les interactions asynchrones avec l'aide d'une bibliothèque telle que suspension ou gen-run .

voici un exemple d'utilisation de la suspension:

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

Liées à la lecture (par la voie de l'auto-promotion éhontée): Quel est le Big Deal avec des Générateurs? .

fonction de sommeil simple et élégante utilisant Javascript moderne

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

Pas de dépendance, pas de rappel de l'enfer; c'est tout :-)

compte tenu de l'exemple donné dans la question, voici comment nous attendrons entre deux consoles:

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

main();

l ' "inconvénient" est que votre fonction principale doit être async ainsi. Mais, considérant que vous écrivez déjà Javascript moderne code, vous devriez utiliser async / await partout dans votre code, donc ce n'est vraiment pas un problème. Tous les navigateurs modernes aujourd'hui prise en charge it.

donnant un petit aperçu de la fonction sleep pour ceux qui ne sont pas habitués à async/await , vous pouvez aussi l'écrire comme ceci:

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

en utilisant l'opérateur fat arrow, cependant, le rend encore plus petit (et plus élégant).

la solution la plus courte sans aucune dépendance:

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

j'ai récemment créé une abstraction plus simple appelée attendez.pour appeler les fonctions asynchrones en mode sync (basé sur les fibres des noeuds). Il existe également une version basée sur les générateurs ES6 à venir.

https://github.com/luciotato/waitfor

par attendre.pour , vous pouvez appeler n'importe quelle fonction async standard de nodejs, comme si c'était une fonction sync, sans bloquer la boucle d'événement de node.

vous pouvez coder séquentiellement quand vous en avez besoin, ce qui est (je suppose) parfait pour simplifier vos scripts pour un usage personnel.

par attendre.pour votre code sera:

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. 

N'importe quelle fonction async peut aussi être appelée en mode Sync . Vérifiez les exemples.

sur Linux / nodejs cela fonctionne pour moi:

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

var sommeil = spawnSync (en mode "veille", [1.5]);

il bloque, mais ce n'est pas une boucle d'attente occupée.

le temps que vous spécifiez est en secondes mais peut être une fraction. Je ne sais pas si les autres OS ont une commande similaire.

je voulais un sommeil asynchrone qui fonctionnait sous Windows et Linux, sans encombrer mon CPU d'une longue boucle. J'ai essayé le sleep package mais il ne s'installait pas sur ma fenêtre. J'ai fini par utiliser:

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

pour l'installer, tapez:

npm install system-sleep

dans votre code,

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

Fonctionne comme un charme.

si vous voulez "code golf" vous pouvez faire une version plus courte de certaines des autres réponses ici:

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

mais vraiment la réponse idéale à mon avis est D'utiliser la bibliothèque util de Node et sa fonction promisify , qui est conçu pour exactement ce genre de chose (faire des versions basées sur la promesse de choses existantes non basées sur la promesse): "15198090920"

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

dans les deux cas, vous pouvez ensuite faire une pause simplement en utilisant await pour appeler votre fonction sleep :

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

puisque javascript engine (v8) exécute le code basé sur la séquence d'événements dans event-queue, il n'y a pas de restriction que javascript déclenche exactement l'exécution après l'heure spécifiée. C'est-à-dire que lorsque vous définissez quelques secondes pour exécuter le code plus tard, le code de déclenchement est purement de base sur la séquence dans la file d'événements. Ainsi, le déclenchement de l'exécution du code peut prendre plus de temps que spécifié.

Sorte De Nœud.js suit,

process.nextTick()

pour exécuter le code plus tard setTimeout (). Par exemple,

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

avec ES6 supportant Promise s, nous pouvons les utiliser sans aucune aide de tiers.

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.

alors utilisez - le comme ceci:

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

notez que la fonction doWhat devient le resolve callback dans le new Promise(...) .

notez aussi qu'il s'agit d'un sommeil asynchrone. Il ne bloque pas la boucle d'événements. Si vous avez besoin de bloquer le sommeil, utilisez cette bibliothèque qui réalise le blocage du sommeil avec l'aide de Reliures C++. (Bien que le besoin d'un sommeil bloquant dans les environnements asynchrones soit rare.)

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

ce code ci-dessus est l'effet secondaire de la résolution du problème de rappel asynchrone de Javascript. C'est aussi la raison pour laquelle je pense que Javascript est un langage utile dans le backend. En fait, il s'agit de l'amélioration la plus passionnante introduit à Javascript moderne à mon avis. Pour bien comprendre comment cela fonctionne, il faut bien comprendre le fonctionnement du générateur. Le mot-clé function suivi d'un * est appelé une fonction de générateur dans moderne JavaScript. Le paquet npm co fournit une fonction runner pour faire fonctionner un générateur.

essentiellement fonction de générateur a fourni un moyen d'interrompre l'exécution d'une fonction avec yield mot-clé, en même temps, yield dans une fonction de générateur a permis d'échanger des informations entre l'intérieur du générateur et l'appelant. Cela a fourni un mécanisme pour l'appelant pour extraire des données d'un promise d'un appel asynchrone et de passer la résolution données vers le générateur. Effectivement, il rend un appel asynchrone et synchrone.

si vous avez juste besoin de suspendre pour tester l'exécution du thread, essayez ceci:

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

simple nous allons attendre 5 secondes pour qu'un événement se produise (qui serait indiqué par la variable done placée à true ailleurs dans le code) ou quand le délai expire que nous vérifierons tous les 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;
        }
    })();

pour certaines personnes, la réponse acceptée ne fonctionne pas, j'ai trouvé cette autre réponse et elle fonctionne pour moi: Comment puis-je passer un paramètre à un rappel setTimeout ()?

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

"bonjour" est le paramètre passé, vous pouvez passer tous les paramètres après la durée de temporisation. Merci à @Fabio Phms pour la réponse.

regardez readline-sync ( https://www.npmjs.com/package/readline-sync )

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

Peut-être pas la meilleure pratique, mais fait le travail pour moi

c'est un moment.module aromatisé js basé sur l'approche de blocage sale suggérée par @atlex2 . utilisez ceci seulement pour les essais .

const moment = require('moment');

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

module.exports = sleep;

les autres réponses sont excellentes mais j'ai pensé que je prendrais un tact différent.

si tout ce que vous cherchez vraiment est de ralentir un fichier spécifique sous linux:

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

node myprog slowfile

1 seconde toutes les 5 lignes. Le nœud programme, aussi lent que l'écrivain. Si elle fait autre chose, elle continuera à la vitesse normale.

le mkfifo crée un first-in-first-out tuyau. C'est ce qui rend ce travail. La ligne perl écrira aussi vite que vous le voulez. Le $ / =1 dit de ne pas amortir la sortie.

pour plus d'informations sur

yield sleep(2000); 

vous devez cocher Redux-Saga . Mais il est spécifique à votre choix de Redux comme cadre Modèle (bien que strictement non nécessaire).

j'ai assemblé, après avoir lu les réponses à cette question, une fonction simple qui peut aussi faire un rappel, si vous avez besoin de cela:

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