Обновление от января 2021 г.: вы даже можете сделать это в интерактивном режиме Node REPL, используя флаг --experimental-repl-await.

$ node --experimental-repl-await
> const delay = ms => new Promise(resolve => setTimeout(resolve, ms))
> await delay(1000) /// waiting 1 second.

Новый ответ на старый вопрос. Сегодня (январь 2017 июнь 2019) все намного проще. Вы можете использовать новый синтаксис async/await. Например:

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

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

Чтобы использовать async/await из коробки без установки дополнительных модулей, вы должны использовать node-v7 или node-v8, используя флаг --harmony.

Обновление, июнь 2019 г.. Используя последние версии NodeJS, вы можете использовать его прямо из коробки. Не нужно указывать аргументы командной строки. Даже Google Chrome поддерживает его сегодня.

Обновление, май 2020 г .: Скоро вы сможете использовать синтаксис await вне асинхронной функции. На верхнем уровне, как в этом примере

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

Предложение находится на этапе 3. Вы можете использовать его сегодня, используя webpack 5 (альфа),

Дополнительная информация:

• Флаг гармонии в Nodejs: https://nodejs.org/en/docs/es6/
• Все версии NodeJS для загрузки: https://nodejs.org/en/download/releases/

Кратчайшее решение без зависимостей:

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

Лучший способ сделать это - разбить код на несколько функций, например:

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

Это похоже на решение JohnnyHK, но намного проще и проще в расширении.

Это простая техника блокировки:

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

Это блокировка, поскольку в вашем скрипте больше ничего не произойдет (например, обратные вызовы). Но поскольку это консольный скрипт, возможно, это то, что вам нужно!

Поместите код, который вы хотите выполнить после задержки, в обратном вызове setTimeout:

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

На узле 7.6.0 или выше

Node изначально поддерживает ожидание:

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

тогда, если вы можете использовать асинхронные функции:

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

or:

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

В старых версиях Node (исходный ответ)

Мне нужен асинхронный сон, который работал бы в Windows и Linux, не перегружая мой процессор долгим циклом while. Я попробовал спящий пакет, но он не установился на моем компьютере с Windows. В итоге я использовал:

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

Чтобы установить его, введите:

npm install system-sleep

В вашем коде

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

Работает как шарм.

Простая и элегантная функция сна с использованием современного Javascript

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

Никаких зависимостей, никакого ада обратного вызова; это оно :-)

Учитывая пример, приведенный в вопросе, мы будем спать между двумя консольными журналами следующим образом:

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

main();

«Недостатком» является то, что ваша основная функция теперь тоже должна быть async. Но, учитывая, что вы уже пишете современный код Javascript, вы, вероятно (или, по крайней мере, должны использовать!), Используете _4 _ / _ 5_ во всем своем коде, так что это действительно не проблема. Все современные браузеры сегодня поддерживают его.

Чтобы немного разобраться в функции sleep для тех, кто не привык к async/await и операторам жирной стрелки, вот подробный способ ее написания:

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

Однако использование оператора жирной стрелки делает его еще меньше (и более элегантным).

Вы можете использовать этот www.npmjs.com/package/sleep

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

Это довольно старый вопрос, но недавно V8 добавил генераторы, которые могут выполнять то, что запрашивал OP. Генераторы, как правило, проще всего использовать для асинхронного взаимодействия с помощью такой библиотеки, как suspend или gen-run.

Вот пример использования приостановки:

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

Чтение по теме (в порядке бессовестной саморекламы): В чем дело с генераторами? .

Если вы хотите кодировать гольф, вы можете сделать более короткую версию некоторых других ответов здесь:

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

Но на самом деле идеальным ответом, на мой взгляд, является использование библиотеки Node util и ее функции promisify, которая предназначена именно для такого рода вещей (создание основанных на обещаниях версий ранее существовавших вещей, не основанных на обещаниях):

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

В любом случае вы можете сделать паузу, просто используя await для вызова вашей sleep функции:

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

РЕДАКТИРОВАТЬ: Как отмечалось в комментариях, вы даже можете сократить это до одной строки:

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

Или, если вы даже не хотите беспокоиться о создании sleep функции:

await require('util').promisify(setTimeout)(1000);

В Linux / nodejs это работает для меня:

const spawnSync = требуется ('дочерний_процесс'). spawnSync;

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

Это блокирующий, но не занятый цикл ожидания.

Время, которое вы указываете, указывается в секундах, но может быть дробным. Я не знаю, есть ли в других ОС аналогичная команда.

Недавно я создал более простую абстракцию под названием wait.for для вызова асинхронных функций в режиме синхронизации (на основе узловых волокон). Также есть версия, основанная на грядущих генераторах ES6.

https://github.com/luciotato/waitfor

Используя wait.for, вы можете вызвать любую стандартную асинхронную функцию nodejs, как если бы это была функция синхронизации, без блокировки цикла событий узла.

Вы можете кодировать последовательно, когда вам это нужно, что (я предполагаю) идеально подходит для упрощения ваших скриптов для личного использования.

используя wait.for, ваш код будет:

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. 

Также любая асинхронная функция может быть вызвана в режиме Sync. Проверьте примеры.

Поскольку механизм javascript (v8) запускает код на основе последовательности событий в очереди событий, не существует строгих требований, чтобы javascript точно запускал выполнение по истечении указанного времени. То есть, когда вы устанавливаете несколько секунд для выполнения кода позже, запускающий код полностью зависит от последовательности в очереди событий. Таким образом, запуск выполнения кода может занять больше указанного времени.

Итак, Node.js следует,

process.nextTick()

для запуска кода позже вместо setTimeout (). Например,

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

Поскольку ES6 поддерживает Promises, мы можем использовать их без какой-либо сторонней помощи.

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.

Затем используйте это так:

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

Обратите внимание, что функция doWhat становится обратным вызовом resolve в new Promise(...).

Также обратите внимание, что это АСИНХРОННЫЙ сон. Он не блокирует цикл событий. Если вам нужно заблокировать сон, используйте эту библиотеку, которая реализует блокировку сна с помощью привязок C ++. (Хотя необходимость в блокирующем режиме сна в Node-подобных асинхронных средах возникает редко.)

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

Попробуйте использовать обещание, у меня это работает в NodeJS

один лайнер

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

или использовать его как функцию в NodeJS для повторного использования

const sleep = async (milliseconds) => {
    await new Promise(resolve => setTimeout(resolve, milliseconds));
}

используйте функцию типа

await sleep(5000)

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

Этот код выше является побочным эффектом решения проблемы ада асинхронного обратного вызова Javascript. Это также причина, по которой я считаю, что Javascript является полезным языком для серверной части. На самом деле, на мой взгляд, это самое захватывающее улучшение, внесенное в современный Javascript. Чтобы полностью понять, как это работает, необходимо полностью понять, как работает генератор. Ключевое слово function, за которым следует *, в современном Javascript называется функцией генератора. Пакет npm co предоставляет функцию runner для запуска генератора.

По сути, функция генератора предоставляет способ приостановить выполнение функции с помощью ключевого слова yield, в то же время yield в функции генератора позволяет обмениваться информацией между внутренним генератором и вызывающей стороной. Это предоставило вызывающей стороне механизм для извлечения данных из promise из асинхронного вызова и для передачи разрешенных данных обратно в генератор. Фактически он делает асинхронный вызов синхронным.

Это модуль со вкусом moment.js, основанный на подходе грязной блокировки, предложенном @ atlex2. Используйте это только для тестирования.

const moment = require('moment');

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

module.exports = sleep;

просто, мы собираемся подождать 5 секунд, пока не произойдет какое-то событие (это будет обозначено переменной done, установленной в true где-то еще в коде) или когда истечет тайм-аут, мы будем проверять каждые 100 мс

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

Для некоторых людей принятый ответ не работает, я нашел другой ответ, и он работает для меня: Как передать параметр в функцию обратного вызова setTimeout ()?

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

'hello' - это передаваемый параметр, вы можете передать все параметры по истечении времени ожидания. Спасибо @Fabio Phms за ответ.

function doThen(conditional,then,timer) {
    var timer = timer || 1;
    var interval = setInterval(function(){
        if(conditional()) {
            clearInterval(interval);
            then();
        }
    }, timer);
}

Пример использования:

var counter = 1;
doThen(
    function() {
        counter++;
        return counter == 1000;
    },
    function() {
        console.log("Counter hit 1000"); // 1000 repeats later
    }
)

Если вам просто нужно приостановить выполнение текущего потока, попробуйте следующее:

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

Другие ответы хороши, но я подумал, что выберу другой такт.

Если все, что вам действительно нужно, это замедлить работу определенного файла в Linux:

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

узел myprog slowfile

Это будет спать 1 секунду каждые пять строк. Программа узла будет работать так же медленно, как писатель. Если он выполняет другие действия, они продолжат работу с нормальной скоростью.

Mkfifo создает канал «первым пришел - первым вышел». Это то, что заставляет это работать. Строка perl будет писать так быстро, как вы хотите. $ | = 1 говорит, что вывод не буферизируется.

Прочитав ответы на этот вопрос, я собрал простую функцию, которая также может выполнять обратный вызов, если вам это нужно:

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

Для получения дополнительной информации о

yield sleep(2000); 

вам следует проверить Redux-Saga. Но это зависит от вашего выбора Redux в качестве модельного фреймворка (хотя это и не обязательно).