Ответ 1

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

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, но намного опережает и упрощается.

Ответ 2

Новый ответ на старый вопрос. Сегодня (январь 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 поддерживает это сегодня.

Больше информации:

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

Ответ 3

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

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

Ответ 4

Это простой метод блокировки:

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

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

Ответ 5

Простая и элегантная функция сна с использованием современного 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, вы, вероятно, (или, по крайней мере, должны!) Использовать async/await всем коде, так что это действительно не проблема. Все современные браузеры сегодня поддерживают это.

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

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

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

Ответ 6

Самое короткое решение без каких-либо зависимостей:

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

Ответ 7

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

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

Ответ 8

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

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

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

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

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

или же:

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

На старых версиях Node (оригинальный ответ)

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

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

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

npm install system-sleep

В вашем коде

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

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

Ответ 9

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

Вот пример использования 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');
})();

Связанное чтение (посредством бесстыдной саморекламы): Какая большая сделка с генераторами?.

Ответ 10

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

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

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

Он блокируется, но он не занят циклом ожидания.

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

Ответ 11

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

https://github.com/luciotato/waitfor

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

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

используя 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. 

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

Ответ 12

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

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

Ответ 13

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

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

process.nextTick()

чтобы позже запустить код вместо setTimeout(). Например,

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

Ответ 14

Если ES6 поддерживает Promise s, мы можем использовать их без помощи сторонних разработчиков.

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(...).

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

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

Ответ 15

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 из асинхронного вызова и передавал разрешенные данные обратно генератору. Фактически, он делает синхронный асинхронный вызов.

Ответ 16

Это ароматизированный модуль 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;

Ответ 17

Если вам просто нужно приостановить тестирование, вы выполняете текущее выполнение потока:

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

Ответ 18

просто мы будем ждать 5 секунд для того, чтобы какое-то событие произошло (это будет указано, если указанная переменная установлена ​​в 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;
        }
    })();

Ответ 19

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

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

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

Ответ 20

Посмотрите на readline-sync (https://www.npmjs.com/package/readline-sync)

Установить с помощью 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);
  }
}

Может быть, не самая лучшая практика, но делает работу для меня

Ответ 21

Другие ответы велики, но я думал, что возьму другой такт.

Если все, что вы действительно ищете, это замедлить определенный файл в linux:

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

node myprog slowfile

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

mkfifo создает первую очередь в первом канале. Это то, что делает эту работу. Линия perl будет писать так быстро, как вы хотите. Утверждение $| = 1 не буферизует вывод.

Ответ 22

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

yield sleep(2000); 

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

Ответ 23

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

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