有没有比下面的pausecomp函数（取自此处）更好的方法来设计JavaScript中的睡眠？
function pausecomp(millis)
{
var date = new Date();
var curDate = null;
do { curDate = new Date(); }
while(curDate-date < millis);
}
这不是JavaScript中的Sleep的重复-动作之间的延迟；我希望在函数的中间有一个真正的睡眠，而不是在代码执行之前有一段延迟。
当前回答
在服务器端，您可以使用deasync sleep（）方法，该方法在C中本地实现，因此它可以有效地实现等待效果，而不会阻塞事件循环或将CPU置于100%负载。
例子：
#!/usr/bin/env node
// Requires `npm install --save deasync`
var sleep = require("deasync").sleep;
sleep(5000);
console.log ("Hello World!!");
但是，如果您需要一个纯JavaScript函数（例如，通过浏览器在客户端运行它），我很抱歉地说，我认为您的pausecomp（）函数是实现它的唯一方法，而且，除此之外：
这不仅会暂停函数，还会暂停整个事件循环。因此，将不会参加其他活动。它使您的CPU处于100%负载。
因此，如果您需要它作为浏览器脚本，并且不希望出现这些可怕的效果，我必须说，您应该以某种方式重新思考您的功能：
a） 。您可以在超时时调用它（或调用do_the_rest（）函数）。如果您不期望从函数中得到任何结果，则使用更简单的方法。
b） 。或者，如果你需要等待结果，那么你应该使用promise（当然，也可以使用回调地狱；-））。
无预期结果示例：
function myFunc() {
console.log ("Do some things");
setTimeout(function doTheRest(){
console.log ("Do more things...");
}, 5000);
// Returns undefined.
};
myFunc();
返回promise的示例（注意它会改变函数的用法）：
function myFunc(someString) {
return new Promise(function(resolve, reject) {
var result = [someString];
result.push("Do some things");
setTimeout(function(){
result.push("Do more things...");
resolve(result.join("\n"));
}, 5000);
});
};
// But notice that this approach affect to the function usage...
// (It returns a promise, not actual data):
myFunc("Hello!!").then(function(data){
console.log(data);
}).catch(function(err){
console.error(err);
});
其他回答
对于希望将循环执行的一组调用隔开的特定情况，可以使用类似于下面代码的原型。如果没有原型，可以用setTimeout替换延迟函数。
function itemHandler(item)
{
alert(item);
}
var itemSet = ['a','b','c'];
// Each call to itemHandler will execute
// 1 second apart
for(var i=0; i<itemSet.length; i++)
{
var secondsUntilExecution = i;
itemHandler.delay(secondsUntilExecution, item)
}
如果你写一个这样的睡眠函数
var sleep = function(period, decision, callback){
var interval = setInterval(function(){
if (decision()) {
interval = clearInterval(interval);
callback();
}
}, period);
}
你有一个异步函数可以多次调用，
var xhr = function(url, callback){
// Make an Ajax request
// Call a callback when the request fulfils
}
您的项目设置如下：
var ready = false;
function xhr1(){
xhr(url1, function(){ ready = true;});
}
function xhr2(){
xhr(url2, function(){ ready = true; });
}
function xhr3(){
xhr(url3, function(){ ready = true; });
}
然后您可以执行以下操作：
xhr1();
sleep(100, function(){ return done; }, xhr2);
sleep(100, function(){ return done; }, xhr3);
sleep(100, function(){ return done; }, function(){
// Do more
});
而不是像这样无休止的回调缩进：
xhr(url1, function(){
xhr2(url2, function(){
xhr3(url3, function(){
// Do more
});
});
});
我浏览了一天的解决方案，但我仍在思考如何在使用回调时保持可链接性。
每个人都熟悉传统的编程风格，即以同步的方式逐行运行代码。SetTimeout使用回调，因此下一行不会等待它完成。这让我思考如何使其“同步”，从而实现“睡眠”功能。
从一个简单的协同程序开始：
function coroutine() {
console.log('coroutine-1:start');
sleepFor(3000); // Sleep for 3 seconds here
console.log('coroutine-2:complete');
}
我想中间睡3秒钟，但我不想控制整个流程，所以协同程序必须由另一个线程执行。我考虑Unity Yield Instruction，并按以下方式修改协程：
function coroutine1() {
this.a = 100;
console.log('coroutine1-1:start');
return sleepFor(3000).yield; // Sleep for 3 seconds here
console.log('coroutine1-2:complete');
this.a++;
}
var c1 = new coroutine1();
声明sleepFor原型：
sleepFor = function(ms) {
var caller = arguments.callee.caller.toString();
var funcArgs = /\(([\s\S]*?)\)/gi.exec(caller)[1];
var args = arguments.callee.caller.arguments;
var funcBody = caller.replace(/^[\s\S]*?sleepFor[\s\S]*?yield;|}[\s;]*$/g,'');
var context = this;
setTimeout(function() {
new Function(funcArgs, funcBody).apply(context, args);
}, ms);
return this;
}
运行协同程序1（我在InternetExplorer11和Chrome49中进行了测试）后，您将看到它在两个控制台语句之间休眠3秒。它使代码与传统样式一样漂亮。
棘手的一点是在睡眠中。它将调用者函数体作为字符串读取，并将其分成两部分。拆下上部并通过下部创建另一个功能。等待指定的毫秒数后，它通过应用原始上下文和参数来调用创建的函数。对于原始流，它将像往常一样以“返回”结束。为了“收益”？它用于正则表达式匹配。这是必要的，但毫无用处。
它根本不是100%完美，但它至少实现了我的工作。我不得不提到使用这段代码时的一些限制。当代码被分成两部分时，“return”语句必须在外部，而不是在任何循环或{}中。即
function coroutine3() {
this.a = 100;
console.log('coroutine3-1:start');
if(true) {
return sleepFor(3000).yield;
} // <- Raise an exception here
console.log('coroutine3-2:complete');
this.a++;
}
上述代码一定有问题，因为所创建的函数中不能单独存在右括号。另一个限制是“var xxx=123”声明的所有局部变量都不能传递到下一个函数。您必须使用“this.xxx=123”来实现相同的目标。如果您的函数有参数，并且它们发生了更改，则修改后的值也无法传递到下一个函数。
function coroutine4(x) { // Assume x=abc
var z = x;
x = 'def';
console.log('coroutine4-1:start' + z + x); // z=abc, x=def
return sleepFor(3000).yield;
console.log('coroutine4-2:' + z + x); // z=undefined, x=abc
}
我将介绍另一个函数原型：waitFor
waitFor = function(check, ms) {
var caller = arguments.callee.caller.toString();
var funcArgs = /\(([\s\S]*?)\)/gi.exec(caller)[1];
var args = arguments.callee.caller.arguments;
var funcBody = caller.replace(/^[\s\S]*?waitFor[\s\S]*?yield;|}[\s;]*$/g,'');
var context = this;
var thread = setInterval(function() {
if(check()) {
clearInterval(thread);
new Function(funcArgs, funcBody).apply(context, args);
}
}, ms?ms:100);
return this;
}
它等待“check”函数，直到它返回true。它每100毫秒检查一次值。您可以通过传递额外的参数来调整它。考虑测试协程2：
function coroutine2(c) {
/* Some code here */
this.a = 1;
console.log('coroutine2-1:' + this.a++);
return sleepFor(500).yield;
/* Next */
console.log('coroutine2-2:' + this.a++);
console.log('coroutine2-2:waitFor c.a>100:' + c.a);
return waitFor(function() {
return c.a>100;
}).yield;
/* The rest of the code */
console.log('coroutine2-3:' + this.a++);
}
也是我们迄今为止喜爱的漂亮款式。实际上，我讨厌嵌套回调。很容易理解，协程2将等待协程1的完成。有趣的好的，然后运行以下代码：
this.a = 10;
console.log('outer-1:' + this.a++);
var c1 = new coroutine1();
var c2 = new coroutine2(c1);
console.log('outer-2:' + this.a++);
输出为：
outer-1:10
coroutine1-1:start
coroutine2-1:1
outer-2:11
coroutine2-2:2
coroutine2-2:waitFor c.a>100:100
coroutine1-2:complete
coroutine2-3:3
在初始化协程1和协程2后，立即完成外部。然后，协程1将等待3000毫秒。等待500毫秒后，子程序2将进入步骤2。之后，一旦检测到协程1.a值>100，它将继续执行步骤3。
请注意，有三种上下文可以保存变量“a”。一个是外部，值为10和11。另一个在协程1中，其值为100和101。最后一个在协程2中，其值为1、2和3。在协程2中，它还等待来自协程1的c.a，直到其值大于100。3个上下文是独立的。
复制和粘贴的完整代码：
sleepFor = function(ms) {
var caller = arguments.callee.caller.toString();
var funcArgs = /\(([\s\S]*?)\)/gi.exec(caller)[1];
var args = arguments.callee.caller.arguments;
var funcBody = caller.replace(/^[\s\S]*?sleepFor[\s\S]*?yield;|}[\s;]*$/g,'');
var context = this;
setTimeout(function() {
new Function(funcArgs, funcBody).apply(context, args);
}, ms);
return this;
}
waitFor = function(check, ms) {
var caller = arguments.callee.caller.toString();
var funcArgs = /\(([\s\S]*?)\)/gi.exec(caller)[1];
var args = arguments.callee.caller.arguments;
var funcBody = caller.replace(/^[\s\S]*?waitFor[\s\S]*?yield;|}[\s;]*$/g,'');
var context = this;
var thread = setInterval(function() {
if(check()) {
clearInterval(thread);
new Function(funcArgs, funcBody).apply(context, args);
}
}, ms?ms:100);
return this;
}
function coroutine1() {
this.a = 100;
console.log('coroutine1-1:start');
return sleepFor(3000).yield;
console.log('coroutine1-2:complete');
this.a++;
}
function coroutine2(c) {
/* Some code here */
this.a = 1;
console.log('coroutine2-1:' + this.a++);
return sleepFor(500).yield;
/* next */
console.log('coroutine2-2:' + this.a++);
console.log('coroutine2-2:waitFor c.a>100:' + c.a);
return waitFor(function() {
return c.a>100;
}).yield;
/* The rest of the code */
console.log('coroutine2-3:' + this.a++);
}
this.a = 10;
console.log('outer-1:' + this.a++);
var c1 = new coroutine1();
var c2 = new coroutine2(c1);
console.log('outer-2:' + this.a++);
它在Internet Explorer 11和Chrome 49中进行了测试。因为它使用arguments.callee，所以如果在严格模式下运行可能会有麻烦。
对于浏览器，我同意使用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光纤，睡眠
我知道这个问题是关于睡眠的，显然答案是不可能的。我认为睡眠的一个常见需求是按顺序处理异步任务；我知道我肯定要处理它。
在许多情况下，它可以使用promise（Ajax请求通用）。它们允许您以同步方式进行异步操作。还有成功/失败的处理，它们可以被链接起来。
它们是ECMAScript 6的一部分，所以浏览器支持还不完全，主要是Internet Explorer不支持它们。还有一个名为Q的库，用于实现承诺。
参考文献：
JavaScript承诺：简介ES6 Promise：ES6风格Promise的polyfill（Shim适用于旧版浏览器或Internet Explorer浏览器）
