如何在Node.js（JavaScript）中等待？我需要暂停一段时间

我正在为个人需要开发一个控制台脚本。我需要能够暂停更长的时间，但是，根据我的研究，Node.js无法根据需要停止。经过一段时间后，阅读用户信息变得越来越困难。。。我已经看到了一些代码，但我相信它们必须有其他代码才能工作，例如：

setTimeout（函数（）{
}, 3000);

但是，我需要这行代码之后的所有内容在一段时间后执行

比如说,

//代码的开头
log（'欢迎使用我的控制台'）；
有些人在这里等了十秒钟。。。
console.log（“诸如此类诸如此类额外诸如此类”）；
//代码结束

我也见过类似的事情

产量睡眠（2000）；

但是Node.js没有意识到这一点

---

如何实现此延长暂停？

将延迟后要执行的代码放入

setTimeout

回调中：

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

---

最好的方法是将代码分解为多个函数，如下所示：

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

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

它类似于JohnnyHK的解决方案，但更简洁、更易于扩展。

由于javascript引擎（v8）根据事件队列中的事件序列运行代码，因此javascript在指定时间后准确触发执行并不严格。也就是说，当您设置稍后执行代码的秒数时，触发代码完全基于事件队列中的序列。因此，触发代码的执行可能需要超过指定的时间

因此Node.js如下所示

process.nextTick()

要稍后运行代码，请改为setTimeout（）。比如说,

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

---

这个问题很老了，但最近V8增加了发电机，可以实现OP要求的功能。在库（如或）的帮助下，生成器通常最容易用于异步交互

下面是一个使用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');
})();

---

相关阅读（通过无耻的自我宣传）：.

我最近创建了一个更简单的抽象，名为wait.for以同步模式调用异步函数（基于节点光纤）。还有一个基于即将推出的ES6生成器的版本

使用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. 

也可以在同步模式下调用任何异步函数。 检查示例。

您可以使用此选项

---

这是一种简单的阻塞技术：

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

它是阻塞的，因为脚本中不会发生任何其他事情（如回调）。但由于这是一个控制台脚本，也许这就是您需要的

有关

yield sleep(2000); 

---

你应该检查一下。但是它是特定于您选择Redux作为模型框架的（尽管严格来说没有必要）。

在阅读了这个问题的答案后，我将一个简单的函数放在一起，如果您需要，它还可以执行回调：

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

---

在Linux/nodejs上，这对我很有用：

const spawnSync=require（'child_process'）。spawnSync

var sleep=spawnSync（'sleep'，[1.5]）

它是阻塞的，但不是繁忙的等待循环

---

指定的时间以秒为单位，但可以是小数。我不知道其他操作系统是否有类似的命令。

如果您只是为了测试目的需要挂起当前线程执行，请尝试以下操作：

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

函数longExecFunc（回调，计数）{ 对于（var j=0；j

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

然后，如果可以使用异步函数：

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

或：

在较旧的节点版本上（原始答案） 我想要一个在Windows和Linux中工作的异步睡眠，而不需要长时间的循环占用我的CPU。我尝试了睡眠软件包，但它没有安装在我的Windows机箱上。我最终使用了：

要安装，请键入：

npm install system-sleep

在代码中

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

---

工作起来很有魅力。

更新2021年1月：您甚至可以在节点REPL interactive中使用

--experimental REPL await

标志执行此操作

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

一个旧问题的新答案。今天（2017年1月至2019年6月）更简单。您可以使用。 例如：

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年6月更新：通过使用最新版本的NodeJS，您可以开箱即用。无需提供命令行参数。即使谷歌浏览器现在也支持它

2020年5月更新： 很快，您将能够在异步函数之外使用

wait

语法

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

。 您现在可以通过使用webpack 5（alpha）使用它

更多信息：

• Nodejs中的和谐标志：
• 要下载的所有NodeJS版本：

上面的代码是解决Javascript异步回调地狱问题的副作用。这也是我认为Javascript成为后端有用语言的原因。实际上，在我看来，这是现代Javascript中引入的最令人兴奋的改进。要完全理解它的工作原理，需要对生成器的工作原理进行分析完全理解。

function

关键字后跟

*

在现代Javascript中称为生成器函数。npm包

co

提供了运行生成器的运行函数

本质上，生成器函数提供了一种暂停执行带有

yield

关键字的函数的方法，同时，生成器函数中的

yield

使生成器内部和调用方之间的信息交换成为可能。这为

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

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

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

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

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

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

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

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

main();

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

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

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

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

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

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

const moment = require('moment');

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

module.exports = sleep;

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

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

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

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

await sleep(5000)