我建议以前的python开发人员使用此方法

const sleep = (time) => {
   return new Promise((resolve) => setTimeout(resolve, Math.ceil(time * 1000)));
};

用法：

await sleep(10) // for 10 seconds

在JavaScript中，我重写了每个函数，以便它能够尽快结束。您希望浏览器恢复控制，以便它可以更改DOM。

每次我想在函数中间休眠时，我都会重构以使用setTimeout（）。

Edit

任何语言中臭名昭著的睡眠或延迟功能都备受争议。有些人会说，应该总是有一个信号或回调来启动给定的功能，而另一些人会认为，有时任意的延迟时间是有用的。我说，每个人都有自己的规则，在这个行业中，一条规则永远无法支配任何事情。

编写睡眠函数很简单，而且使用JavaScript Promises更容易使用：

// sleep time expects milliseconds
function sleep (time) {
  return new Promise((resolve) => setTimeout(resolve, time));
}

// Usage!
sleep(500).then(() => {
    // Do something after the sleep!
});

使用三种功能：

调用setInterval启动循环的函数一个函数，它调用clearInterval来停止循环，然后调用setTimeout来休眠，最后在setTimeout内调用作为回调来重新启动循环一个循环，跟踪迭代次数，设置睡眠次数和最大次数，一旦达到睡眠次数就调用睡眠函数，并在达到最大次数后调用clearInterval

var foo＝｛｝；函数main（）{“使用严格”；/*初始化全局状态*/foo.bar=foo.bar ||0；/*初始化计时器*/foo.bop=设置间隔（foo.baz，1000）；}睡眠=功能（计时器）{“使用严格”；clearInterval（计时器）；timer=setTimeout（function（）｛main（）｝，5000）；};foo.baz=函数（）{“使用严格”；/*更新状态*/foo.bar=数字（foo.bar+1）||0；/*日志状态*/console.log（foo.bar）；/*检查状态并在10时停止*/（foo.bar===5）&&睡眠（foo.bop）；（foo.bar==10）&&clearInterval（foo.bop）；};main（）；

工具书类

使用JavaScript开发游戏为什么iOS 8中的滚动事件更改是一件大事Ember.js中的实时轮询系统使用requestAnimationFrame（）驱动动画MDN:JavaScript并发模型和事件循环网格研究：Node.js在JavaScript中超过60fps第2部分：不阻塞单个线程的CPU密集型JavaScript计算

你不能在JavaScript中做这样的睡眠，或者更确切地说，你不应该这样做。运行sleep或while循环将导致用户的浏览器挂起，直到循环完成。

使用您引用的链接中指定的计时器。

对于浏览器，我同意使用setTimeout和setInterval。

但是对于服务器端代码，它可能需要一个阻塞函数（例如，这样可以有效地进行线程同步）。

如果您正在使用Node.js和Meteor，您可能遇到了在光纤中使用setTimeout的限制。下面是服务器端睡眠的代码。

var Fiber = require('fibers');

function sleep(ms) {
    var fiber = Fiber.current;
    setTimeout(function() {
        fiber.run();
    }, ms);
    Fiber.yield();
}

Fiber(function() {
    console.log('wait... ' + new Date);
    sleep(1000);
    console.log('ok... ' + new Date);
}).run();
console.log('back in main');

参见：Node.js光纤，睡眠

拥抱JavaScript的异步特性！

以下所有内容都将立即返回，但只有一个地方可以放置发生事件后要运行的代码。

我在这里概述的方法都适用于不同的用例，并根据其复杂性大致排序。

不同之处如下：

等待某些条件变为现实在调用单个回调之前，等待一组方法完成（按任何顺序）在调用回调之前，以特定顺序运行一系列具有共享状态的异步方法

Wait

如果没有任何可访问的回调来告诉您什么时候完成了执行，那么等待某个条件是否为真是非常有用的。

这是一个非常基本的实现，它假设条件在某个时刻变为真。通过一些调整，它可以扩展到更有用（例如，通过设置呼叫限制）。（我昨天才写了这篇！）

function waitFor(predicate, successCallback) {
    setTimeout(function () {
        var result = predicate();
        if (result !== undefined)
            successCallback(result);
        else
            waitFor(predicate, successCallback);
    }, 100);
}

呼叫代码：

beforeEach(function (done) {
    selectListField('A field');

    waitFor(function () {
        var availableOptions = stores.scrapeStore(optionStore);
        if (availableOptions.length !== 0)
            return availableOptions;
    }, done);
});

在这里，我调用了加载ExtJS“store”的东西，并等待该存储包含一些东西后再继续（beforeEach是Jasmine测试框架的东西）。

等待几件事完成

我还需要在加载完不同的方法后运行一个回调。你可以这样做：

createWaitRunner = function (completionCallback) {
    var callback = completionCallback;
    var completionRecord = [];
    var elements = 0;

    function maybeFinish() {
        var done = completionRecord.every(function (element) {
            return element === true
        });

        if (done)
            callback();
    }

    return {
        getNotifier: function (func) {
            func = func || function (){};

            var index = elements++;
            completionRecord[index] = false;

            return function () {
                func.applyTo(arguments);
                completionRecord[index] = true;
                maybeFinish();
            }
        }
    }
};

呼叫代码：

var waiter = createWaitRunner(done);

filterList.bindStore = waiter.getNotifier();
includeGrid.reconfigure = waiter.getNotifier(function (store) {
    includeStore = store;
});

excludeGrid.reconfigure = waiter.getNotifier(function (store) {
    excludeStore = store;
});

您可以只等待通知，也可以包装使用传递给函数的值的其他函数。调用所有方法后，将运行done。

按顺序运行异步方法

当我在一行中调用一系列异步方法时（同样在测试中），我使用了不同的方法。这有点类似于您可以在Async库中得到的东西——series也做了同样的事情，我先读了一下这个库，看看它是否符合我的要求。我认为我的测试有一个更好的API（实现起来很有趣！）。

// Provides a context for running asynchronous methods synchronously
// The context just provides a way of sharing bits of state
// Use 'run' to execute the methods.  These should be methods that take a callback and optionally the context as arguments
// Note the callback is provided first, so you have the option of just partially applying your function to the arguments you want
// instead of having to wrap even simple functions in another function

// When adding steps you can supply either just a function or a variable name and a function
// If you supply a variable name then the output of the function (which should be passed into the callback) will be written to the context
createSynchronisedRunner = function (doneFunction) {
    var context = {};

    var currentPosition = 0;
    var steps = [];

    // This is the loop. It is triggered again when each method finishes
    var runNext = function () {
        var step = steps[currentPosition];
        step.func.call(null,
                       function (output) {
                           step.outputHandler(output);
                           currentPosition++;

                           if (currentPosition === steps.length)
                               return;

                           runNext();
                       }, context);
    };

    var api = {};

    api.addStep = function (firstArg, secondArg) {
        var assignOutput;
        var func;

        // Overloads
        if (secondArg === undefined) {
            assignOutput = function () {
            };
            func = firstArg;
        }
        else {
            var propertyName = firstArg;
            assignOutput = function (output) {
                context[propertyName] = output;
            };
            func = secondArg;
        }

        steps.push({
            func: func,
            outputHandler: assignOutput
        });
    };

    api.run = function (completedAllCallback) {
        completedAllCallback = completedAllCallback || function(){};

        var lastStep = steps[steps.length - 1];
        var currentHandler = lastStep.outputHandler;
        lastStep.outputHandler = function (output) {
            currentHandler(output);
            completedAllCallback(context);
            doneFunction();
        };

        runNext();
    };

    // This is to support more flexible use where you use a done function in a different scope to initialisation
    // For example, the done of a test but create in a beforeEach
    api.setDoneCallback = function (done) {
        doneFunction = done;
    };

    return api;
};

呼叫代码：

beforeAll(function (done) {
    var runner = createSynchronisedRunner(done);
    runner.addStep('attachmentInformation', testEventService.getAttachmentCalled.partiallyApplyTo('cat eating lots of memory.jpg'));
    runner.addStep('attachment', getAttachment.partiallyApplyTo("cat eating lots of memory.jpg"));
    runner.addStep('noAttachment', getAttachment.partiallyApplyTo("somethingElse.jpg"));
    runner.run(function (context) {
        attachment = context.attachment;
        noAttachment = context.noAttachment;
    });
});

这里的PartiallyApplyTo基本上是Douglas Crockford实现Curry的重命名版本。我正在处理的很多东西都将回调作为最后的参数，这样简单的调用就可以这样完成，而不必用一个额外的函数来包装一切。