Я розробляю консоль типу сценарію для особистих потреб. Мені потрібно мати змогу зробити паузу протягом тривалого часу, але, з мого дослідження, 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');
//endcode. 

Я також бачив такі речі

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 етапі . Ви можете використовувати його сьогодні, використовуючи webpack 5 (alpha),

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

• Прапор гармонії в Nodejs: 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 або вище

Вузол підтримує очікування очікування:

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

На старих версіях вузла (оригінальна відповідь)

Я хотів асинхронного сну, який працював у 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 додав Генератори, які можуть виконати те, про що вимагав ОП. Генератори, як правило, найпростіше використовувати для асинхронних взаємодій за допомогою бібліотеки, наприклад, призупинити чи запустити ген .

Ось приклад використання призупинення:

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 = вимагати ('child_process'). spawnSync;

var sleep = spawnSync ('сон', [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 Promise, ми можемо використовувати їх без сторонньої допомоги.

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забезпечував функцію бігуна для запуску генератора.

По суті, функція генератора забезпечувала спосіб призупинення виконання функції з 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 секунд, щоб відбулася якась подія (про що буде позначено виконаною змінною, встановленою на істину десь в коді) або коли закінчиться час очікування, ми перевірятимемо кожні 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); 

'привіт' - це параметр, який передається, ви можете передати всі параметри після закінчення часу. Дякую @Fabio Phms за відповідь.

Замість того, щоб робити всі ці setTimeout, сон та багато інших речей, краще використовувати

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 як вашої моделі моделі (хоча суворо не потрібно).