Я разрабатываю консольный скрипт для личных нужд. Я должен быть в состоянии сделать паузу в течение длительного периода времени, но, согласно моим исследованиям, Node.js не может остановиться как требуется. Через некоторое время становится трудно читать информацию пользователей ... Я видел некоторый код там, но я считаю, что у них должен быть другой код внутри них, чтобы они работали, такие как:

    setTimeout(function() {
    }, 3000);

Тем не менее, мне нужно все после этой строки кода, чтобы выполнить после определенного периода времени.

Например,

    // start of code
    console.log('Welcome to my console,');

    some-wait-code-here-for-ten-seconds...

    console.log('Blah blah blah blah extra-blah');
    // end of code

Я также видел такие вещи, как

    yield sleep(2000);

Но Node.js не распознает это.

Как мне добиться этой продолжительной паузы?

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

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 , но гораздо удобнее и проще в расширении.

Новый ответ на старый вопрос. Сегодня ( январь 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 . Вы можете использовать его сегодня с помощью веб-пакета 5 (альфа),

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

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

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

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

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

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

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

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

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

На узле 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

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

Простая и элегантная функция сна с использованием современного 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);
    });
}

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

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

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

Этот вопрос довольно старый, но недавно 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');
})();

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

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

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

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

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

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

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

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

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

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

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

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

Недавно я создал более простую абстракцию под названием 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. 

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

Поскольку движок 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

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;

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

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

Проще говоря, мы будем ждать 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 за ответ.

Вместо того, чтобы делать все эти setTimeout, sleep и многое другое, лучше использовать

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

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

Если все, что вы действительно ищете, это замедлить определенный файл в 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 в качестве вашей модели фреймворка (хотя строго не обязательно).