有没有比下面的pausecomp函数（取自此处）更好的方法来设计JavaScript中的睡眠？
function pausecomp(millis)
{
var date = new Date();
var curDate = null;
do { curDate = new Date(); }
while(curDate-date < millis);
}
这不是JavaScript中的Sleep的重复-动作之间的延迟；我希望在函数的中间有一个真正的睡眠，而不是在代码执行之前有一段延迟。
当前回答
为了测试，我需要一段忙碌的等待。我不想拆分代码，因为这需要很多工作，所以一个简单的for为我做了这件事。
for (var i=0; i<1000000; i++){
// Waiting
}
我看不出这样做有什么坏处，这对我来说很有好处。
其他回答
出于对$DEITY的热爱，请不要使用忙等待睡眠功能。setTimeout和setInterval可以满足您的需要。
var showHide=document.getElementById（'showHide'）；setInterval（（）=>{showHide.style.visibility=“初始”；setTimeout（（）=>{showHide.style.visibility=“隐藏”}, 1000);}, 2000); ＜div id=“showHide”＞您好！再见</分区>
每隔两秒隐藏文本一秒。这显示了如何使用setInterval和setTimeout每秒显示和隐藏文本。
如果您使用jQuery，实际上有人创建了一个“延迟”插件，它只不过是setTimeout的包装器：
// Delay Plugin for jQuery
// - http://www.evanbot.com
// - © 2008 Evan Byrne
jQuery.fn.delay = function(time,func){
this.each(function(){
setTimeout(func,time);
});
return this;
};
然后，您可以按预期在一行函数调用中使用它：
$('#warning')
.addClass('highlight')
.delay(1000)
.removeClass('highlight');
我浏览了一天的解决方案，但我仍在思考如何在使用回调时保持可链接性。
每个人都熟悉传统的编程风格，即以同步的方式逐行运行代码。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光纤，睡眠
拥抱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的重命名版本。我正在处理的很多东西都将回调作为最后的参数，这样简单的调用就可以这样完成，而不必用一个额外的函数来包装一切。
