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

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

相关阅读（推销自己的方式）：发电机有什么大不了？。

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

或者将其作为一个函数在NodeJS中重复使用

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

使用该函数的方式如下

await sleep(5000)

在Linux/nodejs中，这对我有效：

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

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

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

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

Node 16有了一种新的简单方法来完成它。

import { setTimeout } from 'timers/promises'

console.log('before')
await setTimeout(3000)
console.log('after')

我最近创建了一个更简单的抽象叫做wait.for，它可以在同步模式下调用异步函数（基于node-fibers）。也有一个基于即将推出的ES6生成器的版本。

https://github.com/luciotato/waitfor

使用wait.for，您可以调用任何标准的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. 

任何异步函数都可以以同步模式调用。请查看示例。

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

使用 Promise 是 JavaScript 中实现“等待”的一种方法，正如顶部答案所示。

那么它应该如何使用呢？

这里有一个简单的例子，展示了如何以非阻塞的方式在 5 秒的子进程中排队参数，并将其传递给 4 秒的主进程。

const wait = (seconds) => 
    new Promise(resolve => 
        setTimeout(() => 
            resolve(true), seconds * 1000))

const process = async (items, prepTask, mainTask) => {
    const queue = [];
    let done = false;

    items.forEach((item, i) => {
        prepTask(item).then(() => {
            queue.push(item);
            if (i == items.length -1) {
                done = true;
            }
        })
    })

    while (!done || queue.length) {
        if (queue.length) {
            const workload = queue.shift();
            await mainTask(workload)
        } else {
            console.log('waiting for subtask to queue')
            await wait(1);
        }
    }
}

// Usage Example

const ids = [1,2,3,4,5,6,7,8,9,10];

const prepTask = async (id) => {
    await wait(id * 5)
    return id * 5;
}

const mainTask = async (workload) => {
    console.log('excuting workload: ', workload);
    const result = await wait(4);
    return { workload, result }
}

process(ids, prepTask, mainTask)
    .then(() => console.log('done'))

这是一个基于@atlex2建议的脏阻塞方法的moment.js风格模块。仅用于测试。

const moment = require('moment');

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

module.exports = 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引入的最令人兴奋的改进。要完全理解它的工作原理，需要完全理解生成器的工作原理。在现代JavaScript中，跟随一个*的function关键字称为生成器函数。npm包co提供了一个运行器函数来运行生成器。

本质上，生成器函数提供了一种使用yield关键字暂停函数执行的方法，同时，在生成器函数中使用yield使内部和调用者之间交换信息成为可能。这为调用者从异步调用的promise中提取数据并将已解析的数据传回生成器提供了机制。有效地使异步调用同步化。