blocks|key|1835165|text|看在$DEITY的份上，请不要设置忙等待休眠功能。setTimeout和setInterval可以满足您的所有需求。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1835166|​|1835167|var+showHide+=+document.getElementById('showHide');
setInterval(()+=>+{
++++showHide.style.visibility+=+"initial";
++++setTimeout(()+=>+{
++++++++showHide.style.visibility+=+"hidden"
++++},+1000);
++++;
},+2000);+++|code-block|syntax|javascript|1835168|<div+id="showHide">Hello!+Goodbye!</div>|1835169|1835170|每隔两秒隐藏文本一秒。这展示了如何使用setInterval和setTimeout每秒显示和隐藏文本。|1835171|entityMap^0|P|A|10|B|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Y|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|Z|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|O|3|G|5|6|7|11|8|@]|D|@]|E|$]]|$1|P|3|Q|5|6|7|12|8|@]|D|@]|E|$]]|$1|R|3|-4|5|6|7|13|8|@]|D|@]|E|$]]]|S|$]]

For the love of $DEITY please do not make a busy-wait sleep function. <code>setTimeout</code> and <code>setInterval</code> do everything you need.

<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>var showHide = document.getElementById('showHide');
setInterval(() =&gt; {
 showHide.style.visibility = "initial";
 setTimeout(() =&gt; {
 showHide.style.visibility = "hidden"
 }, 1000);
 ;
}, 2000); </code></pre>
<pre class="snippet-code-html lang-html prettyprint-override"><code>&lt;div id="showHide"&gt;Hello! Goodbye!&lt;/div&gt;</code></pre>
</div>
</div>


Every two second interval hide text for one second. This shows how to use setInterval and setTimeout to show and hide text each second.

blocks|key|2049367|text|你不能在JavaScript中做这样的睡眠，或者更确切地说，你不应该这样做。运行睡眠或while循环会导致用户的浏览器挂起，直到循环完成。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2049368|使用您引用的链接中指定的计时器。|2049369|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

You can't do a sleep like that in JavaScript, or, rather, you shouldn't. Running a sleep or a while loop will cause the user's browser to hang until the loop is done.

Use a timer, as specified in the link you referenced.

blocks|key|2049418|text|在JavaScript中，我重写了每个函数，以便它可以尽快结束。您希望浏览器重新得到控制，这样它就可以对DOM进行更改。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2049419|每当我想在我的函数中间睡一觉时，我就重构为使用setTimeout()。|offset|length|style|CODE|2049420|编辑|2049421|睡眠或延迟在任何语言中的臭名昭著的功能都有很多争论。有些人会说，应该总是有一个信号或回调来触发给定的功能，另一些人会争辩说，有时任意的延迟时刻是有用的。我要说的是，在这个行业中，每个人都有自己的规则，一条规则永远不会决定任何事情。|2049422|编写睡眠函数很简单，使用JavaScript+Promise甚至可以让它变得更有用：|2049423|//+sleep+time+expects+milliseconds
function+sleep+(time)+{
++return+new+Promise((resolve)+=>+setTimeout(resolve,+time));
}

//+Usage!
sleep(500).then(()+=>+{
++++//+Do+something+after+the+sleep!
});|code-block|syntax|javascript|2049424|entityMap^0|0|N|C|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@$D|W|E|X|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|Y|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|Z|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|10|8|@]|9|@]|A|$]]|$1|N|3|O|5|P|7|11|8|@]|9|@]|A|$Q|R]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

In JavaScript, I rewrite every function so that it can end as soon as possible. You want the browser back in control so it can make your DOM changes.

Every time I've wanted a sleep in the middle of my function, I refactored to use a <code>setTimeout()</code>.

<h2>Edit</h2>

The infamous sleep, or delay, function within any language is much debated. Some will say that there should always be a signal or callback to fire a given functionality, others will argue that sometimes an arbitrary moment of delay is useful. I say that to each their own and one rule can never dictate anything in this industry.

Writing a sleep function is simple and made even more usable with JavaScript Promises:

<pre><code>// sleep time expects milliseconds
function sleep (time) {
 return new Promise((resolve) =&gt; setTimeout(resolve, time));
}

// Usage!
sleep(500).then(() =&gt; {
 // Do something after the sleep!
});
</code></pre>

blocks|key|1835293|text|这真的不是一个好主意。这样做会导致整个页面在系统等待函数返回时冻结。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1835294|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

This is really not a good idea. Doing something like this would cause the entire page to freeze up while the system waited for your function to return.

blocks|key|1835358|text|我同意其他的海报。忙碌的睡眠不是一个好主意。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1835359|但是，setTimeout不会阻止执行。它在设置超时后立即执行函数的下一行，而不是在超时到期后执行，因此这不会完成与睡眠相同的任务。|1835360|这样做的方法是将你的函数分解成前后两部分。|1835361|function+doStuff()
{
++//+Do+some+things
++setTimeout(continueExecution,+10000)+//+Wait+ten+seconds+before+continuing
}

function+continueExecution()
{
+++//+Finish+doing+things+after+the+pause
}|code-block|syntax|javascript|1835362|确保您的函数名称仍然准确地描述了每个部分的作用(例如，GatherInputThenWait和CheckInput，而不是funcPart1和funcPart2)|1835363|此方法实现了在超时之前不执行您决定的代码行的目的，同时仍然将控制权返回给客户端PC以执行它排队的任何其他代码行。|1835364|正如评论中指出的那样，这绝对不会在循环中工作。你可以做一些花哨的(丑陋的)黑客来让它在循环中工作，但一般来说，这只会产生灾难性的意大利面条代码。|1835365|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|U|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|V|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

I agree with the other posters. A busy sleep is just a bad idea.
However, setTimeout does not hold up execution. It executes the next line of the function immediately after the timeout is SET, not after the timeout expires, so that does not accomplish the same task that a sleep would accomplish.
The way to do it is to breakdown your function into before and after parts.
<pre><code>function doStuff()
{
 // Do some things
 setTimeout(continueExecution, 10000) // Wait ten seconds before continuing
}

function continueExecution()
{
 // Finish doing things after the pause
}
</code></pre>
Make sure your function names still accurately describe what each piece is doing (i.e., GatherInputThenWait and CheckInput, rather than funcPart1 and funcPart2)
This method achieves the purpose of not executing the lines of code you decide until after your timeout, while still returning control back to the client PC to execute whatever else it has queued up.
As pointed out in the comments this will absolutely not work in a loop. You could do some fancy (ugly) hacking to make it work in a loop, but in general that will just make for disastrous spaghetti code.

blocks|key|1835480|text|如果您使用的是jQuery，那么实际上有人创建了一个“延迟”插件，它只不过是setTimeout的一个包装器：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1835481|//+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;
};|code-block|syntax|javascript|1835482|然后，您可以按照预期在一行函数调用中使用它：|1835483|$('#warning')
.addClass('highlight')
.delay(1000)
.removeClass('highlight');|1835484|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

If you're using jQuery, someone actually created a "delay" plugin that's nothing more than a wrapper for setTimeout:

<pre><code>// 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;
};
</code></pre>

You can then just use it in a row of function calls as expected:

<pre><code>$('#warning')
.addClass('highlight')
.delay(1000)
.removeClass('highlight');
</code></pre>

blocks|key|2049689|text|我已经搜索/谷歌了相当多关于JavaScript睡眠/等待的网页...如果你想让JavaScript“运行，延迟，运行”，没有答案...大多数人得到的是，"+RUN，RUN(无用的东西)，RUN“或者"RUN，RUN%2B+delayed”……|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2049690|我想:这是一个有效的解决方案...但是你必须砍掉你的运行代码...：是的，我知道，这只是一个更容易阅读的重构……不过..。|2049691|示例1：|2049692|<html>
<body>
<div+id="id1">DISPLAY</div>

<script>
//+JavaScript+sleep+by+"therealdealsince1982";+copyrighted+2009
//+setInterval
var+i+=+0;

function+run()+{
++++//+Pieces+of+codes+to+run
++++if+(i+==+0){document.getElementById("id1").innerHTML=+"code+segment+"+%2B+i+%2B+"+is+ran";+}
++++if+(i+==+1){document.getElementById("id1").innerHTML=+"code+segment+"+%2B+i+%2B+"+is+ran";+}
++++if+(i+==+2){document.getElementById("id1").innerHTML=+"code+segment+"+%2B+i+%2B+"+is+ran";+}
++++if+(i+>2){document.getElementById("id1").innerHTML=+"code+segment+"+%2B+i+%2B+"+is+ran";+}
++++if+(i+==+5){document.getElementById("id1").innerHTML=+"all+code+segment+finished+running";+clearInterval(t);+}+//+End+interval,+stops+run
++++i%2B%2B;+//+Segment+of+code+finished+running,+next...
}

run();
t+=+setInterval("run()",+1000);

</script>
</body>
</html>|code-block|syntax|javascript|2049693|示例2：|2049694|<html>
<body>
<div+id="id1">DISPLAY</div>

<script>
//+JavaScript+sleep+by+"therealdealsince1982";+copyrighted+2009
//+setTimeout
var+i+=+0;

function+run()+{
++++//+Pieces+of+codes+to+run,+can+use+switch+statement
++++if+(i+==+0){document.getElementById("id1").innerHTML=+"code+segment+"+%2B+i+%2B+"+ran";+sleep(1000);}
++++if+(i+==+1){document.getElementById("id1").innerHTML=+"code+segment+"+%2B+i+%2B+"+ran";+sleep(2000);}
++++if+(i+==+2){document.getElementById("id1").innerHTML=+"code+segment+"+%2B+i+%2B+"+ran";+sleep(3000);}
++++if+(i+==+3){document.getElementById("id1").innerHTML=+"code+segment+"+%2B+i+%2B+"+ran";}+//stops+automatically
++++i%2B%2B;
}

function+sleep(dur)+{t=setTimeout("run()",+dur);}+//+Starts+flow+control+again+after+'dur'

run();+//+Starts
</script>
</body>
</html>|2049695|示例3：|2049696|<html>
<body>
<div+id="id1">DISPLAY</div>

<script>
//+JavaScript+sleep+by+"therealdealsince1982";+copyrighted+2009
//+setTimeout
var+i+=+0;

function+flow()+{
++++run(i);
++++i%2B%2B;+//+Code+segment+finished+running,+increment+i;+can+put+elsewhere
++++sleep(1000);
++++if+(i+==+5)+{clearTimeout(t);}+//+Stops+flow,+must+be+after+sleep()
}

function+run(segment)+{
++++//+Pieces+of+codes+to+run,+can+use+switch+statement
++++if+(segment+==+0){document.getElementById("id1").innerHTML=+"code+segment+"+%2B+segment+%2B+"+is+ran";+}
++++if+(segment+==+1){document.getElementById("id1").innerHTML=+"code+segment+"+%2B+segment+%2B+"+is+ran";+}
++++if+(segment+==+2){document.getElementById("id1").innerHTML=+"code+segment+"+%2B+segment+%2B+"+is+ran";+}
++++if+(segment+>2){document.getElementById("id1").innerHTML=+"code+segment+"%2B+segment+%2B"+is+ran";+}
}

function+sleep(dur)+{t=setTimeout("flow()",+dur);}+//+Starts+flow+control+again+after+'dur'

flow();+//+Starts+flow
</script>
</body>
</html>|2049697|示例4：|2049698|<html>
<body>
<div+id="id1">DISPLAY</div>

<script>
//+JavaScript+sleep+by+"therealdealsince1982";+copyrighted+2009
//+setTimeout,+switch
var+i+=+0;

function+flow()+{
++++switch(i)
++++{
++++++++case+0:
++++++++++++run(i);
++++++++++++sleep(1000);
++++++++++++break;
++++++++case+1:
++++++++++++run(i);
++++++++++++sleep(2000);
++++++++++++break;
++++++++case+5:
++++++++++++run(i);
++++++++++++clearTimeout(t);+//+Stops+flow
++++++++++++break;
++++++++default:
++++++++++++run(i);
++++++++++++sleep(3000);
++++++++++++break;
++++}
}

function+run(segment)+{
++++//+Pieces+of+codes+to+run,+can+use+switch+statement
++++if+(segment+==+0){document.getElementById("id1").innerHTML=+"code+segment+"+%2B+segment+%2B+"+is+ran";+}
++++if+(segment+==+1){document.getElementById("id1").innerHTML=+"code+segment+"+%2B+segment+%2B+"+is+ran";+}
++++if+(segment+==+2){document.getElementById("id1").innerHTML=+"code+segment+"+%2B+segment+%2B+"+is+ran";+}
++++if+(segment+>2){document.getElementById("id1").innerHTML=+"code+segment+"+%2B+segment+%2B+"+is+ran";+}
++++i%2B%2B;+//+Current+segment+of+code+finished+running,+next...
}

function+sleep(dur)+{t=setTimeout("flow()",+dur);}+//+Starts+flow+control+again+after+'dur'

flow();+//+Starts+flow+control+for+first+time...
</script>
</body>
</html>|2049699|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|11|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|13|8|@]|9|@]|A|$I|J]]|$1|O|3|P|5|6|7|14|8|@]|9|@]|A|$]]|$1|Q|3|R|5|H|7|15|8|@]|9|@]|A|$I|J]]|$1|S|3|T|5|6|7|16|8|@]|9|@]|A|$]]|$1|U|3|V|5|H|7|17|8|@]|9|@]|A|$I|J]]|$1|W|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|X|$]]

I have searched/googled quite a few webpages on JavaScript sleep/wait... and there is no answer if you want JavaScript to &quot;RUN, DELAY, RUN&quot;... what most people got was either, &quot;RUN, RUN(useless stuff), RUN&quot; or &quot;RUN, RUN + delayed RUN&quot;...
I thought:
here is a solution that works... but you have to chop up your running codes...:
Yes, I know, this is just an easier to read refactoring... still...
<h3>Example 1:</h3>
<pre><code>&lt;html&gt;
&lt;body&gt;
&lt;div id=&quot;id1&quot;&gt;DISPLAY&lt;/div&gt;

&lt;script&gt;
// JavaScript sleep by &quot;therealdealsince1982&quot;; copyrighted 2009
// setInterval
var i = 0;

function run() {
 // Pieces of codes to run
 if (i == 0){document.getElementById(&quot;id1&quot;).innerHTML= &quot;&lt;p&gt;code segment &quot; + i + &quot; is ran&lt;/p&gt;&quot;; }
 if (i == 1){document.getElementById(&quot;id1&quot;).innerHTML= &quot;&lt;p&gt;code segment &quot; + i + &quot; is ran&lt;/p&gt;&quot;; }
 if (i == 2){document.getElementById(&quot;id1&quot;).innerHTML= &quot;&lt;p&gt;code segment &quot; + i + &quot; is ran&lt;/p&gt;&quot;; }
 if (i &gt;2){document.getElementById(&quot;id1&quot;).innerHTML= &quot;&lt;p&gt;code segment &quot; + i + &quot; is ran&lt;/p&gt;&quot;; }
 if (i == 5){document.getElementById(&quot;id1&quot;).innerHTML= &quot;&lt;p&gt;all code segment finished running&lt;/p&gt;&quot;; clearInterval(t); } // End interval, stops run
 i++; // Segment of code finished running, next...
}

run();
t = setInterval(&quot;run()&quot;, 1000);

&lt;/script&gt;
&lt;/body&gt;
&lt;/html&gt;
</code></pre>
<h3>Example 2:</h3>
<pre><code>&lt;html&gt;
&lt;body&gt;
&lt;div id=&quot;id1&quot;&gt;DISPLAY&lt;/div&gt;

&lt;script&gt;
// JavaScript sleep by &quot;therealdealsince1982&quot;; copyrighted 2009
// setTimeout
var i = 0;

function run() {
 // Pieces of codes to run, can use switch statement
 if (i == 0){document.getElementById(&quot;id1&quot;).innerHTML= &quot;&lt;p&gt;code segment &quot; + i + &quot; ran&lt;/p&gt;&quot;; sleep(1000);}
 if (i == 1){document.getElementById(&quot;id1&quot;).innerHTML= &quot;&lt;p&gt;code segment &quot; + i + &quot; ran&lt;/p&gt;&quot;; sleep(2000);}
 if (i == 2){document.getElementById(&quot;id1&quot;).innerHTML= &quot;&lt;p&gt;code segment &quot; + i + &quot; ran&lt;/p&gt;&quot;; sleep(3000);}
 if (i == 3){document.getElementById(&quot;id1&quot;).innerHTML= &quot;&lt;p&gt;code segment &quot; + i + &quot; ran&lt;/p&gt;&quot;;} //stops automatically
 i++;
}

function sleep(dur) {t=setTimeout(&quot;run()&quot;, dur);} // Starts flow control again after 'dur'

run(); // Starts
&lt;/script&gt;
&lt;/body&gt;
&lt;/html&gt;
</code></pre>
<h3>Example 3:</h3>
<pre><code>&lt;html&gt;
&lt;body&gt;
&lt;div id=&quot;id1&quot;&gt;DISPLAY&lt;/div&gt;

&lt;script&gt;
// JavaScript sleep by &quot;therealdealsince1982&quot;; copyrighted 2009
// setTimeout
var i = 0;

function flow() {
 run(i);
 i++; // Code segment finished running, increment i; can put elsewhere
 sleep(1000);
 if (i == 5) {clearTimeout(t);} // Stops flow, must be after sleep()
}

function run(segment) {
 // Pieces of codes to run, can use switch statement
 if (segment == 0){document.getElementById(&quot;id1&quot;).innerHTML= &quot;&lt;p&gt;code segment &quot; + segment + &quot; is ran&lt;/p&gt;&quot;; }
 if (segment == 1){document.getElementById(&quot;id1&quot;).innerHTML= &quot;&lt;p&gt;code segment &quot; + segment + &quot; is ran&lt;/p&gt;&quot;; }
 if (segment == 2){document.getElementById(&quot;id1&quot;).innerHTML= &quot;&lt;p&gt;code segment &quot; + segment + &quot; is ran&lt;/p&gt;&quot;; }
 if (segment &gt;2){document.getElementById(&quot;id1&quot;).innerHTML= &quot;&lt;p&gt;code segment &quot;+ segment +&quot; is ran&lt;/p&gt;&quot;; }
}

function sleep(dur) {t=setTimeout(&quot;flow()&quot;, dur);} // Starts flow control again after 'dur'

flow(); // Starts flow
&lt;/script&gt;
&lt;/body&gt;
&lt;/html&gt;
</code></pre>
<h3>Example 4:</h3>
<pre><code>&lt;html&gt;
&lt;body&gt;
&lt;div id=&quot;id1&quot;&gt;DISPLAY&lt;/div&gt;

&lt;script&gt;
// JavaScript sleep by &quot;therealdealsince1982&quot;; copyrighted 2009
// setTimeout, switch
var i = 0;

function flow() {
 switch(i)
 {
 case 0:
 run(i);
 sleep(1000);
 break;
 case 1:
 run(i);
 sleep(2000);
 break;
 case 5:
 run(i);
 clearTimeout(t); // Stops flow
 break;
 default:
 run(i);
 sleep(3000);
 break;
 }
}

function run(segment) {
 // Pieces of codes to run, can use switch statement
 if (segment == 0){document.getElementById(&quot;id1&quot;).innerHTML= &quot;&lt;p&gt;code segment &quot; + segment + &quot; is ran&lt;/p&gt;&quot;; }
 if (segment == 1){document.getElementById(&quot;id1&quot;).innerHTML= &quot;&lt;p&gt;code segment &quot; + segment + &quot; is ran&lt;/p&gt;&quot;; }
 if (segment == 2){document.getElementById(&quot;id1&quot;).innerHTML= &quot;&lt;p&gt;code segment &quot; + segment + &quot; is ran&lt;/p&gt;&quot;; }
 if (segment &gt;2){document.getElementById(&quot;id1&quot;).innerHTML= &quot;&lt;p&gt;code segment &quot; + segment + &quot; is ran&lt;/p&gt;&quot;; }
 i++; // Current segment of code finished running, next...
}

function sleep(dur) {t=setTimeout(&quot;flow()&quot;, dur);} // Starts flow control again after 'dur'

flow(); // Starts flow control for first time...
&lt;/script&gt;
&lt;/body&gt;
&lt;/html&gt;
</code></pre>

blocks|key|2049735|text|对于想要分隔循环执行的一组调用的特定情况，您可以使用类似于以下prototype的代码。在没有原型的情况下，您可以用setTimeout替换延迟函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2049736|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%2B%2B)
{
++++var+secondsUntilExecution+=+i;
++++itemHandler.delay(secondsUntilExecution,+item)
}|code-block|syntax|javascript|2049737|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

For the specific case of wanting to space out a set of calls being executed by a loop, you can use something like the code below with prototype. Without prototype, you can substitute the delay function with setTimeout.

<pre><code>function itemHandler(item)
{
 alert(item);
}

var itemSet = ['a','b','c'];

// Each call to itemHandler will execute
// 1 second apart
for(var i=0; i&lt;itemSet.length; i++)
{
 var secondsUntilExecution = i;
 itemHandler.delay(secondsUntilExecution, item)
}
</code></pre>

blocks|key|2049784|text|你可能想要一个睡眠()函数，而不是使用setTimeout()，如果你有一个响应用户点击的函数，最终将打开一个新的弹出窗口，并且你已经启动了一些处理，在弹出窗口显示之前需要很短的时间来完成。将打开的窗口移动到闭包中意味着它通常会被浏览器阻止。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2049785|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

One scenario where you might want a sleep() function rather than using setTimeout() is if you have a function responding to a user click that will ultimately end up opening a new i.e. popup window and you have initiated some processing that requires a short period to complete before the popup is displayed. Moving the open window into a closure means that it typically gets blocked by the browser.

blocks|key|2049826|text|(请参阅updated+answer+for+2016)|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2049827|我认为，想要执行一个操作，等待，然后执行另一个操作，这是完全合理的。如果您习惯于使用多线程语言编写代码，那么您可能会想到在线程唤醒之前执行一段时间。|2049828|这里的问题是，JavaScript是一个基于事件的单线程模型。虽然在特定的情况下，让整个引擎等待几秒钟可能会很好，但通常这是不好的做法。假设我想在编写自己的函数时使用您的函数？当我调用你的方法时，我的方法都会冻结。如果JavaScript可以以某种方式保存函数的执行上下文，将其存储在某个位置，然后将其带回并在稍后继续，那么可能会发生休眠，但这基本上是线程处理。|2049829|因此，您在很大程度上坚持其他人的建议--您需要将代码分解为多个函数。|2049830|那么，你的问题有点错误的选择。没有办法以你想要的方式睡觉，你也不应该追求你建议的解决方案。|2049831|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/39914235/11236^0|4|N|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@$A|U|B|V|1|W]]|C|$]]|$1|D|3|E|5|6|7|X|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|Y|8|@]|9|@]|C|$]]|$1|H|3|I|5|6|7|Z|8|@]|9|@]|C|$]]|$1|J|3|K|5|6|7|10|8|@]|9|@]|C|$]]|$1|L|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|M|$N|$5|O|P|Q|C|$R|S]]]]

(See the <a href="https://stackoverflow.com/a/39914235/11236">updated answer for 2016</a>)
I think it's perfectly reasonable to want to perform an action, wait, and then perform another action. If you are used to writing in multi-threaded languages, you probably have the idea of yielding execution for a set amount of time until your thread wakes up.
The issue here is that JavaScript is a single-thread event-based model. While in a specific case, it might be nice to have the whole engine wait for a few seconds, in general it is bad practice. Suppose I wanted to make use of your functions while writing my own? When I called your method, my methods would all freeze up. If JavaScript could somehow preserve your function's execution context, store it somewhere, then bring it back and continue later, then sleep could happen, but that would basically be threading.
So you are pretty much stuck with what others have suggested -- you'll need to break your code up into multiple functions.
Your question is a bit of a false choice, then. There is no way to sleep in the way you want, nor should you pursue the solution you suggest.

blocks|key|1835727|text|我也在搜索睡眠解决方案(不是为了产品代码，只是为了开发和测试)，并找到了这篇文章：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1835728|1835729|...and这里有另一篇关于客户端解决方案的文章：|1835730|此外，当您调用alert()时，您的代码也将暂停，同时显示警报--您需要找到一种方法来不显示警报，但获得相同的效果。:)|offset|length|style|CODE|1835731|entityMap^0|0|0|0|7|7|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|N|8|@]|9|@]|A|$]]|$1|C|3|D|5|6|7|O|8|@]|9|@]|A|$]]|$1|E|3|F|5|6|7|P|8|@$G|Q|H|R|I|J]]|9|@]|A|$]]|$1|K|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|L|$]]

I've searched for a sleep solution too (not for production code, only for development and tests) and found this article:
<a href="http://narayanraman.blogspot.com/2005/12/javascript-sleep-or-wait.html" rel="nofollow noreferrer">JavaScript sleep() or wait()</a>
...and here's another article with client-side solutions: <a href="http://www.devcheater.com/" rel="nofollow noreferrer">JavaScript sleep</a>
Also, when you are calling <code>alert()</code>, your code will be paused too, while the alert is shown -- you need to find a way to not display alert, but get the same effect. :)

blocks|key|2049906|text|如果您必须处理同步执行，我可以理解睡眠函数的用途。setInterval和setTimeout函数创建一个并行执行线程，该线程将执行序列返回给主程序，如果您必须等待给定的结果，这是无效的。当然，可以使用事件和处理程序，但在某些情况下并不是这样的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2049907|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I can understand the purpose of a sleep function if you have to deal with synchronous execution. The setInterval and setTimeout functions create a parallel execution thread which returns the execution sequence back to the main program, which is ineffective if you have to wait for a given result. Of course one may use events and handlers, but in some cases is not what is intended.

blocks|key|1835832|text|让事情看起来像大多数人想要的更好的解决方案是使用匿名函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1835833|alert('start');
var+a+=+'foo';
//+Lots+of+code
setTimeout(function(){++//+Beginning+of+code+that+should+run+AFTER+the+timeout
++++alert(a);
++++//+Lots+more+code
},+5000);++//+Put+the+timeout+here|code-block|syntax|javascript|1835834|这可能是最接近你想做的事情了。|1835835|请注意，如果您需要多次睡眠，这可能会在匆忙中变得丑陋，您可能实际上需要重新考虑您的设计。|1835836|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

A better solution to make things look like what most people want is to use an anonymous function:
<pre><code>alert('start');
var a = 'foo';
// Lots of code
setTimeout(function(){ // Beginning of code that should run AFTER the timeout
 alert(a);
 // Lots more code
}, 5000); // Put the timeout here
</code></pre>
This is probably the closest you'll get to something that simply does what you want.
Note, if you need multiple sleeps this can get ugly in a hurry and you might actually need to rethink your design.

blocks|key|1835870|text|如果你想休眠一个匿名函数，比如你创建的一个处理程序，我推荐以下几点：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1835871|function()
{
++++if+(!wait_condition)
++++{
++++++++setTimeout(arguments.callee,+100,+/*+Comma-separated+arguments+here+*/);
++++}
++++//+The+rest+of+the+function
}|code-block|syntax|javascript|1835872|这段代码说：“如果等待条件尚未满足，请使用这些参数再次调用此函数。”我使用这个方法将相同的参数传递给我的处理程序，有效地使这段代码成为一个非轮询的sleep()+(它只在函数开始时起作用)。|1835873|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

If you want to sleep an anonymous function like one you've created as a handler, I recommend the following:
<pre><code>function()
{
 if (!wait_condition)
 {
 setTimeout(arguments.callee, 100, /* Comma-separated arguments here */);
 }
 // The rest of the function
}
</code></pre>
This code says &quot;If the wait condition has not yet been satisfied, call this function again with these arguments.&quot; I've used this method to pass in the same arguments to my handlers, effectively making this code a non-polling sleep() (which only works at the start of your function).

blocks|key|2049981|text|如果(像我一样)在Rhino中使用JavaScript，您可以使用...|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2049982|try
{
++java.lang.Thread.sleep(timeInMilliseconds);
}
catch+(e)
{
++/*
+++*+This+will+happen+if+the+sleep+is+woken+up+-+you+might+want+to+check
+++*+if+enough+time+has+passed+and+sleep+again+if+not+-+depending+on+how
+++*+important+the+sleep+time+is+to+you.
+++*/
}|code-block|syntax|javascript|2049983|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Rhino_%2528JavaScript_engine%2529^0|9|5|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

If (like me) you're using JavaScript with <a href="https://en.wikipedia.org/wiki/Rhino_%28JavaScript_engine%29" rel="nofollow noreferrer">Rhino</a>, you can use...
<pre><code>try
{
 java.lang.Thread.sleep(timeInMilliseconds);
}
catch (e)
{
 /*
 * This will happen if the sleep is woken up - you might want to check
 * if enough time has passed and sleep again if not - depending on how
 * important the sleep time is to you.
 */
}
</code></pre>

blocks|key|2049988|text|从this+link获取的代码不会冻结计算机。但它只能在Firefox中运行。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2049989|/**
+*+Netscape+compatible+WaitForDelay+function.
+*+You+can+use+it+as+an+alternative+to+Thread.Sleep()+in+any+major+programming+language
+*+that+support+it+while+JavaScript+it+self+doesn't+have+any+built-in+function+to+do+such+a+thing.
+*+parameters:
+*+(Number)+delay+in+millisecond
+*/
function+nsWaitForDelay(delay)+{
++++/**
+++++*+Just+uncomment+this+code+if+you're+building+an+extension+for+Firefox.
+++++*+Since+Firefox+3,+we'll+have+to+ask+for+user+permission+to+execute+XPCOM+objects.
+++++*/
++++netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");

++++//+Get+the+current+thread.
++++var+thread+=+Components.classes["@mozilla.org/thread-manager;1"].getService(Components.interfaces.nsIThreadManager).currentThread;

++++//+Create+an+inner+property+to+be+used+later+as+a+notifier.
++++this.delayed+=+true;

++++/*+Call+JavaScript+setTimeout+function
++++++*+to+execute+this.delayed+=+false
++++++*+after+it+finishes.
++++++*/
++++setTimeout("this.delayed+=+false;",+delay);

++++/**
+++++*+Keep+looping+until+this.delayed+=+false
+++++*/
++++while+(this.delayed)+{
++++++++/**
+++++++++*+This+code+will+not+freeze+your+browser+as+it's+documented+in+here:
+++++++++*+https://developer.mozilla.org/en/Code_snippets/Threads#Waiting_for_a_background_task_to_complete
+++++++++*/
++++++++thread.processNextEvent(true);
++++}
}|code-block|syntax|javascript|2049990|entityMap|0|LINK|mutability|MUTABLE|url|http://www.daniweb.com/web-development/javascript-dhtml-ajax/threads/47199^0|1|9|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Code taken from <a href="http://www.daniweb.com/web-development/javascript-dhtml-ajax/threads/47199" rel="nofollow noreferrer">this link</a> will not freeze the computer. But it works only in Firefox.
<pre><code>/**
 * Netscape compatible WaitForDelay function.
 * You can use it as an alternative to Thread.Sleep() in any major programming language
 * that support it while JavaScript it self doesn't have any built-in function to do such a thing.
 * parameters:
 * (Number) delay in millisecond
 */
function nsWaitForDelay(delay) {
 /**
 * Just uncomment this code if you're building an extension for Firefox.
 * Since Firefox 3, we'll have to ask for user permission to execute XPCOM objects.
 */
 netscape.security.PrivilegeManager.enablePrivilege(&quot;UniversalXPConnect&quot;);

 // Get the current thread.
 var thread = Components.classes[&quot;@mozilla.org/thread-manager;1&quot;].getService(Components.interfaces.nsIThreadManager).currentThread;

 // Create an inner property to be used later as a notifier.
 this.delayed = true;

 /* Call JavaScript setTimeout function
 * to execute this.delayed = false
 * after it finishes.
 */
 setTimeout(&quot;this.delayed = false;&quot;, delay);

 /**
 * Keep looping until this.delayed = false
 */
 while (this.delayed) {
 /**
 * This code will not freeze your browser as it's documented in here:
 * https://developer.mozilla.org/en/Code_snippets/Threads#Waiting_for_a_background_task_to_complete
 */
 thread.processNextEvent(true);
 }
}
</code></pre>

blocks|key|1835909|text|需要使用“睡眠”方法的对象的方法，如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1835910|function+SomeObject()+{
++++this.SomeProperty+=+"xxx";
++++return+this;
}
SomeObject.prototype.SomeMethod+=+function+()+{
++++this.DoSomething1(arg1);
++++sleep(500);
++++this.DoSomething2(arg1);
}|code-block|syntax|javascript|1835911|几乎可以翻译成：|1835912|function+SomeObject()+{
++++this.SomeProperty+=+"xxx";
++++return+this;
}
SomeObject.prototype.SomeMethod+=+function+(arg1)+{
++++var+self+=+this;
++++self.DoSomething1(arg1);
++++setTimeout(function+()+{
++++++++self.DoSomething2(arg1);
++++},+500);
}|1835913|不同之处在于，"SomeMethod“的操作在执行"DoSomething2”操作之前返回。"SomeMethod“的调用者不能依赖于此。由于“睡眠”方法不存在，我使用后一种方法并相应地设计我的代码。|1835914|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

A method of an object that needs to use a &quot;sleep&quot; method such as the following:
<pre><code>function SomeObject() {
 this.SomeProperty = &quot;xxx&quot;;
 return this;
}
SomeObject.prototype.SomeMethod = function () {
 this.DoSomething1(arg1);
 sleep(500);
 this.DoSomething2(arg1);
}
</code></pre>
Can almost be translated to:
<pre><code>function SomeObject() {
 this.SomeProperty = &quot;xxx&quot;;
 return this;
}
SomeObject.prototype.SomeMethod = function (arg1) {
 var self = this;
 self.DoSomething1(arg1);
 setTimeout(function () {
 self.DoSomething2(arg1);
 }, 500);
}
</code></pre>
The difference is that the operation of &quot;SomeMethod&quot; returns before the operation &quot;DoSomething2&quot; is executed. The caller of &quot;SomeMethod&quot; cannot depend on this. Since the &quot;Sleep&quot; method does not exists, I use the latter method and design my code accordingly.

blocks|key|2050051|text|在某些情况下，一个很好的选择是显示一个顶级消息面板来停止用户交互，然后在获得您等待的结果时再次隐藏它(异步地)。这允许浏览器继续执行后台任务，但会暂停工作流程，直到您得到结果。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2050052|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

A good alternative in some situations is to display a top-level message panel to stop user interaction, and then hide it again when you get the result you're waiting for (asynchronously). That allows the browser to get on with background tasks, but pauses the workflow until you've got your result back.

blocks|key|1836036|text|这就是你要的。正如代码所说，不要成为一个糟糕的开发人员，并在网站上使用它。它是一个开发实用函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1836037|//+Basic+sleep+function+based+on+ms.
//+DO+NOT+USE+ON+PUBLIC+FACING+WEBSITES.
function+sleep(ms)+{
++++var+unixtime_ms+=+new+Date().getTime();
++++while(new+Date().getTime()+<+unixtime_ms+%2B+ms)+{}
}|code-block|syntax|javascript|1836038|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here you go. As the code says, don't be a bad developer and use this on websites. It's a development utility function.
<pre><code>// Basic sleep function based on ms.
// DO NOT USE ON PUBLIC FACING WEBSITES.
function sleep(ms) {
 var unixtime_ms = new Date().getTime();
 while(new Date().getTime() &lt; unixtime_ms + ms) {}
}
</code></pre>

blocks|key|2050202|text|为了测试，我需要一个忙碌的等待时间。我不想拆分代码，因为那会有很多工作，所以一个简单的for为我做了这件事。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2050203|for+(var+i=0;+i<1000000;+i%2B%2B){++++++++++++++++++
++++//+Waiting
}|code-block|syntax|javascript|2050204|我没有看到这样做有什么坏处，它对我起到了作用。|2050205|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I needed a busy-wait for testing purposes. I didn't want to split the code as that would be a lot of work, so a simple for did it for me.
<pre><code>for (var i=0; i&lt;1000000; i++){ 
 // Waiting
}
</code></pre>
I didn't see any downside in doing this and it did the trick for me.

blocks|key|1836182|text|这可以使用Java的睡眠方法来完成。我已经在Firefox和Internet+Explorer中测试过它，它不会锁定计算机，不会消耗资源，也不会导致无休止的服务器访问。对我来说，这似乎是一个干净的解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1836183|首先，您必须将Java加载到页面上，并使其方法可用。为此，我执行了以下操作：|1836184|<html>
<head>

<script+type="text/javascript">

++function+load()+{
++++var+appletRef+=+document.getElementById("app");
++++window.java+=+appletRef.Packages.java;
++}+//+endfunction

</script>

<body+onLoad="load()">

<embed+id="app"+code="java.applet.Applet"+type="application/x-java-applet"+MAYSCRIPT="true"+width="0"+height="0"+/>|code-block|syntax|javascript|1836185|然后，当您想要在JavaScript代码中轻松地暂停时，您所要做的就是：|1836186|java.lang.Thread.sleep(xxx)|1836187|其中xxx是以毫秒为单位的时间。在我的例子中(作为理由)，这是一家非常小的公司完成后端订单的一部分，我需要打印一张必须从服务器加载的发票。我通过将发票(作为网页)加载到iFrame中，然后打印iFrame来做到这一点。|1836188|当然，我必须等到页面完全加载后才能打印，所以JavaScript代码必须暂停。我通过使用onLoad事件让invoice页面(在iFrame中)更改父页面上隐藏的表单字段来实现这一点。父页面上打印发票的代码如下所示(为清晰起见，将不相关的部分删掉)：|1836189|var+isReady+=+eval('document.batchForm.ready');
isReady.value+=+0;

frames['rpc_frame'].location.href+=+url;

while+(isReady.value+==+0)+{
++java.lang.Thread.sleep(250);
}+//+endwhile

window.frames['rpc_frame'].focus();
window.frames['rpc_frame'].print();|1836190|因此，用户按下按钮，脚本加载发票页，等待，每隔四分之一秒检查一次，查看发票页是否已完成加载，并弹出打印对话框，供用户将其发送到打印机。QED。|1836191|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|12|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|13|8|@]|9|@]|A|$G|H]]|$1|S|3|T|5|6|7|14|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

It can be done using Java's sleep method. I've tested it in Firefox and Internet Explorer and it doesn't lock the computer, chew up resources, or cause endless server hits. It seems like a clean solution to me.
First you have to get Java loaded up on the page and make its methods available. To do that, I did this:
<pre class="lang-html prettyprint-override"><code>&lt;html&gt;
&lt;head&gt;

&lt;script type=&quot;text/javascript&quot;&gt;

 function load() {
 var appletRef = document.getElementById(&quot;app&quot;);
 window.java = appletRef.Packages.java;
 } // endfunction

&lt;/script&gt;

&lt;body onLoad=&quot;load()&quot;&gt;

&lt;embed id=&quot;app&quot; code=&quot;java.applet.Applet&quot; type=&quot;application/x-java-applet&quot; MAYSCRIPT=&quot;true&quot; width=&quot;0&quot; height=&quot;0&quot; /&gt;
</code></pre>
Then, all you have to do when you want a painless pause in your JavaScript code is:
<pre><code>java.lang.Thread.sleep(xxx)
</code></pre>
Where xxx is time in milliseconds. In my case (by way of justification), this was part of back-end order fulfilment at a very small company and I needed to print an invoice that had to be loaded from the server. I did it by loading the invoice (as a webpage) into an iFrame and then printing the iFrame.
Of course, I had to wait until the page was fully loaded before I could print, so the JavaScript code had to pause. I accomplished this by having the invoice page (in the iFrame) change a hidden form field on the parent page with the onLoad event. And the code on the parent page to print the invoice looked like this (irrelevant parts cut for clarity):
<pre><code>var isReady = eval('document.batchForm.ready');
isReady.value = 0;

frames['rpc_frame'].location.href = url;

while (isReady.value == 0) {
 java.lang.Thread.sleep(250);
} // endwhile

window.frames['rpc_frame'].focus();
window.frames['rpc_frame'].print();
</code></pre>
So the user pushes the button, the script loads the invoice page, waits, checking every quarter second to see if the invoice page is finished loading, and pops up the print dialog for the user to send it to the printer. QED.

blocks|key|2050424|text|或者只需创建以下内容：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2050425|function+yourFunction(){

+++//+Do+something
+++setInterval(myFunc(),+1000);
+++//+Do+something+else
}

function+myFunc(){
+++return;
}|code-block|syntax|javascript|2050426|这将等待指定的时间间隔，并调用不执行任何操作的函数。|2050427|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Or just create this:
<pre><code>function yourFunction(){

 // Do something
 setInterval(myFunc(), 1000);
 // Do something else
}

function myFunc(){
 return;
}
</code></pre>
This will just wait the interval specified and call the function which will just do nothing.

blocks|key|2050530|text|对于浏览器，我同意setTimeout和setInterval是最好的选择。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2050531|但是对于服务器端代码，它可能需要一个阻塞函数(例如，这样您就可以有效地进行线程同步)。|2050532|如果您正在使用Node.js和Meteor，您可能会遇到在光纤中使用setTimeout的限制。以下是服务器端休眠的代码。|offset|length|2050533|var+Fiber+=+require('fibers');

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

Fiber(function()+{
++++console.log('wait...+'+%2B+new+Date);
++++sleep(1000);
++++console.log('ok...+'+%2B+new+Date);
}).run();
console.log('back+in+main');|code-block|syntax|javascript|2050534|请参阅：|2050535|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Node.js|1|https://en.wikipedia.org/wiki/Meteor_%2528web_framework%2529^0|0|0|7|7|0|F|6|1|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@$F|11|G|12|1|13]|$F|14|G|15|1|16]]|A|$]]|$1|H|3|I|5|J|7|17|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|18|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]|W|$5|R|S|T|A|$U|X]]]]

For browsers, I agree that setTimeout and setInterval are the way to go.
But for server-side code, it may require a blocking function (for example, so you can effectively have thread synchronization).
If you're using <a href="https://en.wikipedia.org/wiki/Node.js" rel="nofollow noreferrer">Node.js</a> and <a href="https://en.wikipedia.org/wiki/Meteor_%28web_framework%29" rel="nofollow noreferrer">Meteor</a>, you may have run into the limitations of using setTimeout in a fiber. Here is the code for server-side sleep.
<pre><code>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');
</code></pre>
See: <a href="https://github.com/laverdet/node-fibers#sleep" rel="nofollow noreferrer">Node.js Fibers, Sleep</a>

blocks|key|2050781|text|如果你像这样写一个睡眠函数|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2050782|var+sleep+=+function(period,+decision,+callback){
++++var+interval+=+setInterval(function(){
++++++++if+(decision())+{
++++++++++++interval+=+clearInterval(interval);
++++++++++++callback();
++++++++}
++++},+period);
}|code-block|syntax|javascript|2050783|而且你有一个异步函数可以多次调用，|2050784|var+xhr+=+function(url,+callback){
++++//+Make+an+Ajax+request
++++//+Call+a+callback+when+the+request+fulfils
}|2050785|你可以这样设置你的项目：|2050786|var+ready+=+false;

function+xhr1(){
++++xhr(url1,+function(){+ready+=+true;});
}
function+xhr2(){
++++xhr(url2,+function(){+ready+=+true;+});
}
function+xhr3(){
++++xhr(url3,+function(){+ready+=+true;+});
}|2050787|然后你可以这样做：|2050788|xhr1();
sleep(100,+function(){+return+done;+},+xhr2);
sleep(100,+function(){+return+done;+},+xhr3);
sleep(100,+function(){+return+done;+},+function(){
++++//+Do+more
});|2050789|而不是像这样无休止的回调缩进：|2050790|xhr(url1,+function(){
++++xhr2(url2,+function(){
++++++++xhr3(url3,+function(){
++++++++++++//+Do+more
++++++++});
++++});
});|2050791|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|14|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|16|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|W|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|X|$]]

If you write a sleep function like this
<pre><code>var sleep = function(period, decision, callback){
 var interval = setInterval(function(){
 if (decision()) {
 interval = clearInterval(interval);
 callback();
 }
 }, period);
}
</code></pre>
and you have an asynchronous function to call multiple times,
<pre><code>var xhr = function(url, callback){
 // Make an Ajax request
 // Call a callback when the request fulfils
}
</code></pre>
And you set up your project like this:
<pre><code>var ready = false;

function xhr1(){
 xhr(url1, function(){ ready = true;});
}
function xhr2(){
 xhr(url2, function(){ ready = true; });
}
function xhr3(){
 xhr(url3, function(){ ready = true; });
}
</code></pre>
Then you can do this:
<pre><code>xhr1();
sleep(100, function(){ return done; }, xhr2);
sleep(100, function(){ return done; }, xhr3);
sleep(100, function(){ return done; }, function(){
 // Do more
});
</code></pre>
Instead of endless callback indentation like this:
<pre><code>xhr(url1, function(){
 xhr2(url2, function(){
 xhr3(url3, function(){
 // Do more
 });
 });
});
</code></pre>

blocks|key|2050828|text|我使用多线程URL，它将能够中止指向无响应HTML5的同步XMLHttpRequest。这不会阻止浏览器。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2050829|https://gist.github.com/el-gringo/6990785|offset|length|2050830|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|15|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@$D|O|E|P|1|Q]]|A|$]]|$1|F|3|-4|5|6|7|R|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|C]]]]

I use the multithread HTML5 Worker which will be able to abort an synchronous XMLHttpRequest pointing to an unresponsive URL. This does not block the browser.

<a href="https://gist.github.com/el-gringo/6990785" rel="nofollow">https://gist.github.com/el-gringo/6990785</a>

blocks|key|1836738|text|简短的回答是不，不是在JavaScript本身。您的解决方案似乎是唯一不将控制权交还给环境的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1836739|如果环境不支持事件，这是必要的。他们可能也不会支持setTimeout。|1836740|如果你在一个事件驱动的环境中，比如浏览器或Node.js，setTimeout绝对是最好的方式。|offset|length|1836741|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Node.js^0|0|0|L|7|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@$F|S|G|T|1|U]]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

The short answer is no, not in JavaScript by itself. Your solution seems to be the only way to not return control back to the environment.
This is necessary if the environment does not support events. They probably wouldn't support the setTimeout either.
setTimeout is definitely the best way if you are in an event driven environment such as a browser or <a href="https://en.wikipedia.org/wiki/Node.js" rel="nofollow noreferrer">Node.js</a>.

blocks|key|1836745|text|function+sleep(milliseconds)+{
++var+start+=+new+Date().getTime();
++for+(var+i+=+0;+i+<+1e7;+i%2B%2B)+{
++++if+((new+Date().getTime()+-+start)+>+milliseconds){
++++++break;
++++}
++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1836746|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>function sleep(milliseconds) {
 var start = new Date().getTime();
 for (var i = 0; i &lt; 1e7; i++) {
 if ((new Date().getTime() - start) &gt; milliseconds){
 break;
 }
 }
}
</code></pre>

blocks|key|2050887|text|我确信有一百万种方法可以做得更好，但我想我会尝试一下，创建一个对象：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2050888|//+Dxecute+code+consecutively+with+delays+(blocking/non-blocking+internally)
function+timed_functions()
{
++++this.myfuncs+=+[];
++++this.myfuncs_delays+=+[];+//+mirrors+keys+of+myfuncs+--+values+stored+are+custom+delays,+or+-1+for+use+default
++++this.myfuncs_count+=+0;+//+increment+by+1+whenever+we+add+a+function
++++this.myfuncs_prev++++=+-1;+//+previous+index+in+array
++++this.myfuncs_cur++++=+0;+//+current+index+in+array
++++this.myfuncs_next++=+0;+//+next+index+in+array
++++this.delay_cur+++++=+0;+//+current+delay+in+ms
++++this.delay_default+=+0;+//+default+delay+in+ms
++++this.loop+=+false;++++++//+will+this+object+continue+to+execute+when+at+end+of+myfuncs+array?
++++this.finished+=+false;++//+are+we+there+yet?
++++this.blocking+=+true;+++//+wait+till+code+completes+before+firing+timer?
++++this.destroy+=+false;+++//+<advanced>+destroy+self+when+finished


++++this.next_cycle+=+function()+{
++++++++var+that++=+this;
++++++++var+mytimer+=+this.delay_default;

++++++++if(this.myfuncs_cur+>+-1)
++++++++++++if(this.myfuncs_delays[this.myfuncs_cur]+>+-1)
++++++++++++++++mytimer+=+this.myfuncs_delays[this.myfuncs_cur];

++++++++console.log("fnc:"+%2B+this.myfuncs_cur);
++++++++console.log("timer:"+%2B+mytimer);
++++++++console.log("custom+delay:"+%2B+this.myfuncs_delays[this.myfuncs_cur]);
++++++++setTimeout(function()+{
++++++++//+Time+is+up!+Next+cycle...
++++++++that.cycle();

++++},+mytimer);
}

this.cycle+=+function()+{

++++//+Now+check+how+far+we+are+along+our+queue..+is+this+the+last+function?
++++if(this.myfuncs_next+%2B+1+>+this.myfuncs_count)
++++{
++++++++if(this.loop)
++++++++{
++++++++++++console.log('looping..');
++++++++++++this.myfuncs_next+=+0;
++++++++}
++++++++else
++++++++++++this.finished+=+true;
++++}

++++//+First+check+if+object+isn't+finished
++++if(this.finished)
++++++++return+false;

++++//+HANDLE+NON+BLOCKING+//
++++if(this.blocking+!=+true)+//+Blocking+disabled
++++{
++++++++console.log("NOT+BLOCKING");
++++++++this.next_cycle();
++++}

++++//+Set+prev+=+current,+and+current+to+next,+and+next+to+new+next
++++this.myfuncs_prev+=+this.myfuncs_cur;
++++this.myfuncs_cur++=+this.myfuncs_next;
++++this.myfuncs_next%2B%2B;

++++//+Execute+current+slot
++++this.myfuncs[this.myfuncs_cur]();

++++//+HANDLE+BLOCKING
++++if(this.blocking+==+true)++//+Blocking+enabled
++++{
++++++++console.log("BLOCKING");
++++++++this.next_cycle();
++++}

++++return+true;
};

//+Adders
this.add+=+{
++++that:this,

++++fnc:+function(aFunction)+{
++++++++//+Add+to+the+function+array
++++++++var+cur_key+=+this.that.myfuncs_count%2B%2B;
++++++++this.that.myfuncs[cur_key]+=+aFunction;
++++++++//+Add+to+the+delay+reference+array
++++++++this.that.myfuncs_delays[cur_key]+=+-1;
++++}
};+//+end::this.add

//+setters
this.set+=+{
++++that:this,

++++delay:+function(ms)+{
++++++++var+cur_key+=+this.that.myfuncs_count+-+1;
++++++++//+This+will+handle+the+custom+delay+array+this.that.myfunc_delays
++++++++//+Add+a+custom+delay+to+your+function+container

++++++++console.log("setting+custom+delay.+key:+"%2B+cur_key+%2B+"+msecs:+"+%2B+ms);
++++++++if(cur_key+>+-1)
++++++++{
++++++++++++this.that.myfuncs_delays[cur_key]+=+ms;
++++++++}
++++++++//+So+now+we+create+an+entry+on+the+delay+variable
++++},

++++delay_cur:++++++function(ms)+{+this.that.delay_cur+=+ms;+},
++++delay_default:++function(ms)+{+this.that.delay_default+=+ms;+},
++++loop_on:++++++++function()+++{+this.that.loop+=+true;+},
++++loop_off:+++++++function()+++{+this.that.loop+=+false;+},
++++blocking_on:++++function()+++{+this.that.blocking+=+true;+},
++++blocking_off:+++function()+++{+this.that.blocking+=+false;+},

++++finished:++++++++++++function(aBool)+{+this.that.finished+=+true;+}
};+//+end::this.set


//+Setters
this.get+=+{
++++that:this,

++++delay_default:+function()+{+return+this.that.delay_default;+},
++++delay_cur:+++++function()+{+return+this.that.delay_cur;+}
++++};+//+end::this.get

}+//+end:::function+timed_functions()|code-block|syntax|javascript|2050889|并像这样使用它：|2050890|//+//+//+BEGIN+::+TEST+//+//+//

//+Initialize
var+fncTimer+=+new+timed_functions;

//+Set+some+defaults
fncTimer.set.delay_default(1000);
fncTimer.set.blocking_on();
//+fncTimer.set.loop_on();
//+fncTimer.set.loop_off();


//+BEGIN+::+ADD+FUNCTIONS+(they+will+fire+off+in+order)
fncTimer.add.fnc(function()+{
++++console.log('plan+a+(2+secs)');
});
fncTimer.set.delay(2000);+//+Set+a+custom+delay+for+previously+added+function

fncTimer.add.fnc(function()+{
++++console.log('hello+world+(delay+3+seconds)');
});
fncTimer.set.delay(3000);

fncTimer.add.fnc(function()+{
++++console.log('wait+4+seconds...');
});
fncTimer.set.delay(4000);

fncTimer.add.fnc(function()+{
++++console.log('wait+2+seconds');
});
fncTimer.set.delay(2000);

fncTimer.add.fnc(function()+{
++++console.log('finished.');
});
//+END+::+ADD+FUNCTIONS


//+NOW+RUN
fncTimer.cycle();+//+Begin+execution


//+//+//+END+::+TEST+//+//+//|2050891|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I'm sure there is a million ways to do this one better, but I thought I would give it a try by creating an object:
<pre><code>// Dxecute code consecutively with delays (blocking/non-blocking internally)
function timed_functions()
{
 this.myfuncs = [];
 this.myfuncs_delays = []; // mirrors keys of myfuncs -- values stored are custom delays, or -1 for use default
 this.myfuncs_count = 0; // increment by 1 whenever we add a function
 this.myfuncs_prev = -1; // previous index in array
 this.myfuncs_cur = 0; // current index in array
 this.myfuncs_next = 0; // next index in array
 this.delay_cur = 0; // current delay in ms
 this.delay_default = 0; // default delay in ms
 this.loop = false; // will this object continue to execute when at end of myfuncs array?
 this.finished = false; // are we there yet?
 this.blocking = true; // wait till code completes before firing timer?
 this.destroy = false; // &lt;advanced&gt; destroy self when finished


 this.next_cycle = function() {
 var that = this;
 var mytimer = this.delay_default;

 if(this.myfuncs_cur &gt; -1)
 if(this.myfuncs_delays[this.myfuncs_cur] &gt; -1)
 mytimer = this.myfuncs_delays[this.myfuncs_cur];

 console.log(&quot;fnc:&quot; + this.myfuncs_cur);
 console.log(&quot;timer:&quot; + mytimer);
 console.log(&quot;custom delay:&quot; + this.myfuncs_delays[this.myfuncs_cur]);
 setTimeout(function() {
 // Time is up! Next cycle...
 that.cycle();

 }, mytimer);
}

this.cycle = function() {

 // Now check how far we are along our queue.. is this the last function?
 if(this.myfuncs_next + 1 &gt; this.myfuncs_count)
 {
 if(this.loop)
 {
 console.log('looping..');
 this.myfuncs_next = 0;
 }
 else
 this.finished = true;
 }

 // First check if object isn't finished
 if(this.finished)
 return false;

 // HANDLE NON BLOCKING //
 if(this.blocking != true) // Blocking disabled
 {
 console.log(&quot;NOT BLOCKING&quot;);
 this.next_cycle();
 }

 // Set prev = current, and current to next, and next to new next
 this.myfuncs_prev = this.myfuncs_cur;
 this.myfuncs_cur = this.myfuncs_next;
 this.myfuncs_next++;

 // Execute current slot
 this.myfuncs[this.myfuncs_cur]();

 // HANDLE BLOCKING
 if(this.blocking == true) // Blocking enabled
 {
 console.log(&quot;BLOCKING&quot;);
 this.next_cycle();
 }

 return true;
};

// Adders
this.add = {
 that:this,

 fnc: function(aFunction) {
 // Add to the function array
 var cur_key = this.that.myfuncs_count++;
 this.that.myfuncs[cur_key] = aFunction;
 // Add to the delay reference array
 this.that.myfuncs_delays[cur_key] = -1;
 }
}; // end::this.add

// setters
this.set = {
 that:this,

 delay: function(ms) {
 var cur_key = this.that.myfuncs_count - 1;
 // This will handle the custom delay array this.that.myfunc_delays
 // Add a custom delay to your function container

 console.log(&quot;setting custom delay. key: &quot;+ cur_key + &quot; msecs: &quot; + ms);
 if(cur_key &gt; -1)
 {
 this.that.myfuncs_delays[cur_key] = ms;
 }
 // So now we create an entry on the delay variable
 },

 delay_cur: function(ms) { this.that.delay_cur = ms; },
 delay_default: function(ms) { this.that.delay_default = ms; },
 loop_on: function() { this.that.loop = true; },
 loop_off: function() { this.that.loop = false; },
 blocking_on: function() { this.that.blocking = true; },
 blocking_off: function() { this.that.blocking = false; },

 finished: function(aBool) { this.that.finished = true; }
}; // end::this.set


// Setters
this.get = {
 that:this,

 delay_default: function() { return this.that.delay_default; },
 delay_cur: function() { return this.that.delay_cur; }
 }; // end::this.get

} // end:::function timed_functions()
</code></pre>
And use it like:
<pre><code>// // // BEGIN :: TEST // // //

// Initialize
var fncTimer = new timed_functions;

// Set some defaults
fncTimer.set.delay_default(1000);
fncTimer.set.blocking_on();
// fncTimer.set.loop_on();
// fncTimer.set.loop_off();


// BEGIN :: ADD FUNCTIONS (they will fire off in order)
fncTimer.add.fnc(function() {
 console.log('plan a (2 secs)');
});
fncTimer.set.delay(2000); // Set a custom delay for previously added function

fncTimer.add.fnc(function() {
 console.log('hello world (delay 3 seconds)');
});
fncTimer.set.delay(3000);

fncTimer.add.fnc(function() {
 console.log('wait 4 seconds...');
});
fncTimer.set.delay(4000);

fncTimer.add.fnc(function() {
 console.log('wait 2 seconds');
});
fncTimer.set.delay(2000);

fncTimer.add.fnc(function() {
 console.log('finished.');
});
// END :: ADD FUNCTIONS


// NOW RUN
fncTimer.cycle(); // Begin execution


// // // END :: TEST // // //
</code></pre>

blocks|key|1836792|text|您可以使用闭包调用setTimeout()，并以增量方式增大值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1836793|var+items+=+['item1',+'item2',+'item3'];

function+functionToExecute(item)+{
++console.log('function+executed+for+item:+'+%2B+item);
}

$.each(items,+function+(index,+item)+{
++var+timeoutValue+=+index+*+2000;
++setTimeout(function()+{
++++console.log('waited+'+%2B+timeoutValue+%2B+'+milliseconds');
++++functionToExecute(item);
++},+timeoutValue);
});|code-block|syntax|javascript|1836794|结果：|1836795|waited+0+milliseconds
function+executed+for+item:+item1
waited+2000+milliseconds
function+executed+for+item:+item2
waited+4000+milliseconds
function+executed+for+item:+item3|1836796|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

You can use a closure call setTimeout() with incrementally larger values.
<pre><code>var items = ['item1', 'item2', 'item3'];

function functionToExecute(item) {
 console.log('function executed for item: ' + item);
}

$.each(items, function (index, item) {
 var timeoutValue = index * 2000;
 setTimeout(function() {
 console.log('waited ' + timeoutValue + ' milliseconds');
 functionToExecute(item);
 }, timeoutValue);
});
</code></pre>
Result:
<pre class="lang-none prettyprint-override"><code>waited 0 milliseconds
function executed for item: item1
waited 2000 milliseconds
function executed for item: item2
waited 4000 milliseconds
function executed for item: item3
</code></pre>

blocks|key|1836874|text|如果您希望得到一个不要降低性能的建议。setTimeout是您期望的sleep。但是，如果你想要一种代码被sleep“分成中间”的语法，我们可以这样做：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1836875|sleep+=+function(tm,+fn){
+++window.setTimeout(fn,+tm);
}|code-block|syntax|javascript|1836876|然后，准备如下所示的函数：|1836877|var+fnBeforeSleep+=+function(){

++//+All+code+before+sleep

}

var+fnAfterSleep+=+function(){

++//+All+code+after+sleep

}|1836878|然后：|1836879|fnBeforeSleep();
sleep(2000,+fnAfterSleep);

//+Yep!+Syntactically,+it+is+very+close+to:

fnBeforeSleep();
sleep(2000);
fnAfterSleep();|1836880|entityMap^0|J|A|Y|5|1H|5|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|12|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|14|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|S|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|T|$]]

If you like an advise to not lose performance. <code>setTimeout</code> is your expected <code>sleep</code>.
However, if you want a syntax where code is &quot;divided in middle&quot; by <code>sleep</code>, we can do:
<pre><code>sleep = function(tm, fn){
 window.setTimeout(fn, tm);
}
</code></pre>
Then, prepare functions as in the following:
<pre><code>var fnBeforeSleep = function(){

 // All code before sleep

}

var fnAfterSleep = function(){

 // All code after sleep

}
</code></pre>
Then:
<pre><code>fnBeforeSleep();
sleep(2000, fnAfterSleep);

// Yep! Syntactically, it is very close to:

fnBeforeSleep();
sleep(2000);
fnAfterSleep();
</code></pre>

blocks|key|2051065|text|这里的大多数答案都是被误导的，或者至少是过时的。JavaScript没有理由必须是单线程的，事实上也不是。现在所有主流浏览器都支持workers。在此之前，Rhino和Node.js等其他JavaScript运行时都支持多线程。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2051066|“JavaScript是单线程的”不是有效答案。例如，在工作线程中运行睡眠函数不会阻塞在UI线程中运行的任何代码。|2051067|在支持生成器和收益的较新运行时中，可以为单线程环境中的睡眠函数带来类似的功能：|2051068|//+This+is+based+on+the+latest+ES6+drafts.
//+JavaScript+1.7%2B+(SpiderMonkey/Firefox+2%2B)+syntax+is+slightly+different

//+Run+code+you+want+to+sleep+here+(omit+star+if+using+JavaScript+1.7)
function*+main(){
++++for+(var+i+=+0;+i+<+10;+i%2B%2B)+{
++++++++//+To+sleep+for+10+milliseconds+10+times+in+a+row
++++++++yield+10;
++++}

++++yield+5;
++++console.log('I+just+slept+5+milliseconds!');
}

//+Resume+the+given+generator+after+ms+milliseconds
function+resume(ms,+generator){
++++setTimeout(function(){
++++++++//+Omit+.value+if+using+JavaScript+1.7
++++++++var+nextSleep+=+generator.next().value;
++++++++resume(nextSleep,+generator);
++++},+ms);
}

//+Initialize+a+generator+and+get+first+sleep+for+the+recursive+function
var
++++generator+=+main(),
++++firstSleep+=+generator.next().value;

//+Initialize+recursive+resume+function
resume(firstSleep,+generator);|code-block|syntax|javascript|2051069|这种对睡眠的模拟不同于真正的睡眠函数，因为它不会阻塞线程。它只是在JavaScript当前的setTimeout函数之上加糖。此功能类型已经在Task.js中实现，现在应该可以在Firefox中使用。|2051070|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Rhino_%2528JavaScript_engine%2529|1|http://taskjs.org/^0|26|5|0|0|0|0|0|1Z|7|1|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|6|7|12|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|13|8|@]|9|@]|C|$]]|$1|H|3|I|5|J|7|14|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|15|8|@]|9|@$A|16|B|17|1|18]]|C|$]]|$1|O|3|-4|5|6|7|19|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]|W|$5|R|S|T|C|$U|X]]]]

Most of the answers here are misguided or at the very least outdated. There is no reason JavaScript has to be single threaded, and indeed it isn't. Today all the mainstream browsers support workers. Before this was the case, other JavaScript runtimes like <a href="https://en.wikipedia.org/wiki/Rhino_%28JavaScript_engine%29" rel="nofollow noreferrer">Rhino</a> and Node.js supported multithreading.
'JavaScript is single threaded' is not a valid answer. For example, running a sleep function within a worker would not block any of the code running in the UI thread.
In newer runtimes supporting generators and yield, one could bring similar functionality to the sleep function in a singlethreaded environment:
<pre><code>// This is based on the latest ES6 drafts.
// JavaScript 1.7+ (SpiderMonkey/Firefox 2+) syntax is slightly different

// Run code you want to sleep here (omit star if using JavaScript 1.7)
function* main(){
 for (var i = 0; i &lt; 10; i++) {
 // To sleep for 10 milliseconds 10 times in a row
 yield 10;
 }

 yield 5;
 console.log('I just slept 5 milliseconds!');
}

// Resume the given generator after ms milliseconds
function resume(ms, generator){
 setTimeout(function(){
 // Omit .value if using JavaScript 1.7
 var nextSleep = generator.next().value;
 resume(nextSleep, generator);
 }, ms);
}

// Initialize a generator and get first sleep for the recursive function
var
 generator = main(),
 firstSleep = generator.next().value;

// Initialize recursive resume function
resume(firstSleep, generator);
</code></pre>
This imitation of sleep is different from a true sleep function as it does not block the thread. It is simply sugar on top of JavaScript's current setTimeout function. This functionality type has been implemented in <a href="http://taskjs.org/" rel="nofollow noreferrer">Task.js</a> and should work today in Firefox.

blocks|key|1837030|text|下面是一个使用同步XMLHttpRequest的简单解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1837031|function+sleep(n){
++var+request+=+new+XMLHttpRequest();
++request.open('GET',+'/sleep.php?n='+%2B+n,+false);++//+`false`+makes+the+request+synchronous
++request.send(null);
}|code-block|syntax|javascript|1837032|文件sleep.php的内容|1837033|<?php+sleep($_GET['n']);|1837034|现在使用以下命令调用它：|1837035|sleep(5);|1837036|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Here's a simple solution using a synchronous XMLHttpRequest:
<pre><code>function sleep(n){
 var request = new XMLHttpRequest();
 request.open('GET', '/sleep.php?n=' + n, false); // `false` makes the request synchronous
 request.send(null);
}
</code></pre>
Contents of file sleep.php:
<pre><code>&lt;?php sleep($_GET['n']);
</code></pre>
Now call it with:
<pre><code>sleep(5);
</code></pre>

blocks|key|1837215|text|如果你想要比setTimeout和setInterval更简洁的函数，你可以把它们包装在函数中，只需颠倒参数的顺序，并给它们起个好名字：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1837216|function+after(ms,+fn){+setTimeout(fn,+ms);+}
function+every(ms,+fn){+setInterval(fn,+ms);+}|code-block|syntax|javascript|1837217|CoffeeScript版本：|1837218|after+=+(ms,+fn)->+setTimeout+fn,+ms
every+=+(ms,+fn)->+setInterval+fn,+ms|1837219|然后，您可以很好地在匿名函数中使用它们：|1837220|after(1000,+function(){
++++console.log("it's+been+a+second");
++++after(1000,+function(){
++++++++console.log("it's+been+another+second");
++++});
});|1837221|现在，它很容易读作"after+N毫秒，...“(或“每N毫秒，...")|1837222|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/CoffeeScript^0|6|A|H|B|0|0|0|C|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|17|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|18|8|@]|D|@$9|19|A|1A|1|1B]]|E|$]]|$1|M|3|N|5|H|7|1C|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1D|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|1E|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|1F|8|@]|D|@]|E|$]]|$1|U|3|-4|5|6|7|1G|8|@]|D|@]|E|$]]]|V|$W|$5|X|Y|Z|E|$10|11]]]]

If you want less clunky functions than <code>setTimeout</code> and <code>setInterval</code>, you can wrap them in functions that just reverse the order of the arguments and give them nice names:
<pre><code>function after(ms, fn){ setTimeout(fn, ms); }
function every(ms, fn){ setInterval(fn, ms); }
</code></pre>
<a href="https://en.wikipedia.org/wiki/CoffeeScript" rel="nofollow noreferrer">CoffeeScript</a> versions:
<pre><code>after = (ms, fn)-&gt; setTimeout fn, ms
every = (ms, fn)-&gt; setInterval fn, ms
</code></pre>
You can then use them nicely with anonymous functions:
<pre><code>after(1000, function(){
 console.log(&quot;it's been a second&quot;);
 after(1000, function(){
 console.log(&quot;it's been another second&quot;);
 });
});
</code></pre>
Now it reads easily as &quot;after N milliseconds, ...&quot; (or &quot;every N milliseconds, ...&quot;)

blocks|key|1837345|text|以防你真的需要一个睡眠()来测试一些东西。但请注意，在大多数情况下，它会在调试过程中使浏览器崩溃--这可能就是您无论如何都需要它的原因。在生产模式下，我将注释掉这个函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1837346|function+pauseBrowser(millis)+{
++++var+date+=+Date.now();
++++var+curDate+=+null;
++++do+{
++++++++curDate+=+Date.now();
++++}+while+(curDate-date+<+millis);
}|code-block|syntax|javascript|1837347|不要在循环中使用new+Date()，除非你想浪费内存、处理能力、电池甚至设备的生命周期。|1837348|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

In case you really need a sleep() just to test something. But be aware that it'll crash the browser most of the times while debugging - probably that's why you need it anyway. In production mode I'll comment out this function.
<pre><code>function pauseBrowser(millis) {
 var date = Date.now();
 var curDate = null;
 do {
 curDate = Date.now();
 } while (curDate-date &lt; millis);
}
</code></pre>
Don't use new Date() in the loop, unless you want to waste memory, processing power, battery and possibly the lifetime of your device.

blocks|key|1837611|text|如果你使用的是Node.js，你可以看看fibers+--+node的一个原生C扩展，一种多线程模拟。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1837612|它允许你做一个真正的sleep，在纤程中阻塞执行，但在主线程和其他纤程中是非阻塞的。|style|CODE|1837613|这里有一个来自他们自己的自述文件的例子：|1837614|//+sleep.js

var+Fiber+=+require('fibers');

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

Fiber(function()+{
++++console.log('wait...+'+%2B+new+Date);
++++sleep(1000);
++++console.log('ok...+'+%2B+new+Date);
}).run();
console.log('back+in+main');|code-block|syntax|javascript|1837615|-结果是：|1837616|$+node+sleep.js
wait...+Fri+Jan+21+2011+22:42:04+GMT%2B0900+(JST)
back+in+main
ok...+Fri+Jan+21+2011+22:42:05+GMT%2B0900+(JST)|1837617|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Node.js|1|https://www.npmjs.com/package/fibers^0|7|7|0|K|6|1|0|A|5|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@$A|13|B|14|1|15]|$A|16|B|17|1|18]]|C|$]]|$1|D|3|E|5|6|7|19|8|@$A|1A|B|1B|F|G]]|9|@]|C|$]]|$1|H|3|I|5|6|7|1C|8|@]|9|@]|C|$]]|$1|J|3|K|5|L|7|1D|8|@]|9|@]|C|$M|N]]|$1|O|3|P|5|6|7|1E|8|@]|9|@]|C|$]]|$1|Q|3|R|5|L|7|1F|8|@]|9|@]|C|$M|N]]|$1|S|3|-4|5|6|7|1G|8|@]|9|@]|C|$]]]|T|$U|$5|V|W|X|C|$Y|Z]]|10|$5|V|W|X|C|$Y|11]]]]

If you're on <a href="https://en.wikipedia.org/wiki/Node.js" rel="nofollow noreferrer">Node.js</a>, you can have a look at <a href="https://www.npmjs.com/package/fibers" rel="nofollow noreferrer">fibers</a> – a native C extension to node, a kind of-multi-threading simulation.
It allows you to do a real <code>sleep</code> in a way which is blocking execution in a fiber, but it's non-blocking in the main thread and other fibers.
Here's an example fresh from their own readme:
<pre><code>// sleep.js

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');
</code></pre>
– and the results are:
<pre><code>$ node sleep.js
wait... Fri Jan 21 2011 22:42:04 GMT+0900 (JST)
back in main
ok... Fri Jan 21 2011 22:42:05 GMT+0900 (JST)
</code></pre>

blocks|key|1838127|text|下面是一种在.hta脚本中休眠的方法，这样当脚本唤醒时，它会按顺序执行下一个命令，这在循环中是必需的。这是真正的睡眠；它不会使处理器在睡眠期间处于繁忙状态。例如，处理器能够在休眠期间下载和呈现页面。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1838128|只有一次，在代码开头的地方，开始|1838129|var+WSHShell+=+new+ActiveXObject+("WScript.Shell");|code-block|syntax|javascript|1838130|如果休眠时间为1秒=+1000毫秒，请执行以下语句|1838131|WSHShell.Run('Sleep.js+1000',+3,+true);|1838132|与脚本位于同一目录中的是文件Sleep.js，其中包含以下一行：|1838133|WScript.Sleep(WScript.Arguments+(0));|1838134|(请注意，0在括号中，而不是括号中。)后者是实际执行睡眠的那一行。前面代码片段中的参数true使调用同步。前面参数中的3似乎没有任何效果，但是您需要一些参数才能使true成为第三个参数。|1838135|微软说“WScript对象……在调用它的属性和方法之前永远不需要被实例化，而且它总是可以从任何脚本文件中获得。”，但事实并非如此。它在像上面这样的独立.js文件中可用，但显然不能在.hta文件使用的.js文件中使用，所以这就是为什么它必须在一个单独的文件中，如上面所述调用的原因。|1838136|entityMap^0|6|4|0|0|0|0|0|E|8|0|0|5|1|17|4|1N|1|29|4|0|23|3|2I|4|2R|3|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|13|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|14|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|15|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|16|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|17|8|@$9|18|A|19|B|C]]|D|@]|E|$]]|$1|S|3|T|5|J|7|1A|8|@]|D|@]|E|$K|L]]|$1|U|3|V|5|6|7|1B|8|@$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]|$9|1G|A|1H|B|C]|$9|1I|A|1J|B|C]]|D|@]|E|$]]|$1|W|3|X|5|6|7|1K|8|@$9|1L|A|1M|B|C]|$9|1N|A|1O|B|C]|$9|1P|A|1Q|B|C]]|D|@]|E|$]]|$1|Y|3|-4|5|6|7|1R|8|@]|D|@]|E|$]]]|Z|$]]

Here is a way to sleep in a <code>.hta</code> script, such that when the script wakes up it executes the next command in sequence, as is necessary in a loop. This is a real sleep; it does not keep a processor busy during the sleep. For example, the processor is able to download and render pages during the sleep.
Just once, near the beginning of the code, go
<pre class="lang-none prettyprint-override"><code>var WSHShell = new ActiveXObject (&quot;WScript.Shell&quot;);
</code></pre>
For a sleep of e.g. 1 second = 1000 milliseconds, execute the statement
<pre><code>WSHShell.Run('Sleep.js 1000', 3, true);
</code></pre>
In the same directory as the script is the file <code>Sleep.js</code>, which contains the following one line:
<pre><code>WScript.Sleep(WScript.Arguments (0));
</code></pre>
(Beware; <code>0</code> is in parentheses, not brackets.) The latter is the line that actually performs the sleep. The argument <code>true</code> in the preceding snippet makes the call synchronous. The <code>3</code> in the preceding argument seems not to have any effect, but you need some argument so that <code>true</code> is the third argument.
Microsoft says &quot;The WScript object ... never needs to be instantiated before invoking its properties and methods, and it is always available from any script file.&quot;, but that's not true. It is available in a free-standing <code>.js</code> file such as the above, but apparently not in a <code>.js</code> file used by a <code>.hta</code> file, so that is why it must be in a separate file, invoked as above.

blocks|key|1838146|text|我会将setTimeOut封装在与其他异步任务保持代码一致性的承诺中：Fiddle中的演示|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1838147|function+sleep(ms)
{
++++return(new+Promise(function(resolve,+reject)+{
++++++++setTimeout(function()+{+resolve();+},+ms);
++++}));
}|code-block|syntax|javascript|1838148|它的用法如下：|1838149|sleep(2000).then(function()+{
+++//+Do+something
});|1838150|如果你习惯于使用Promises，就很容易记住它的语法。|1838151|entityMap|0|LINK|mutability|MUTABLE|url|http://jsfiddle.net/a4gjhpgd/^0|Z|6|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|11|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|12|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|13|8|@]|9|@]|C|$]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]]]

I would encapsulate setTimeOut in a Promise for code consistency with other asynchronous tasks: Demo in <a href="http://jsfiddle.net/a4gjhpgd/" rel="nofollow noreferrer">Fiddle</a>
<pre><code>function sleep(ms)
{
 return(new Promise(function(resolve, reject) {
 setTimeout(function() { resolve(); }, ms);
 }));
}
</code></pre>
It is used like this:
<pre><code>sleep(2000).then(function() {
 // Do something
});
</code></pre>
It is easy to remember the syntax if you are used to using Promises.

blocks|key|1838517|text|总结一下(就像在前面的答案中所说的那样)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1838518|JavaScript中没有内置的睡眠功能。您应该使用setTimeout或setInterval来达到类似的效果。|offset|length|1838519|如果你真的想要，你可以用一个for循环来模拟睡眠功能，如原始问题中所示，但这会让你的CPU疯狂地工作。这将避免CPU利用率问题。下面是一个代码示例：|1838520|​|1838521|//+Works+only+inside+a+web+worker

function+sleep(milliseconds)+{
++++var+req+=+new+XMLHttpRequest();
++++req.open("GET",+"http://192.0.2.0/",+false);
++++req.timeout+=+milliseconds;
++++try+{
++++++++req.send();
++++}+catch+(ex)+{

++++}
}

console.log('Sleeping+for+1+second...');
sleep(1000);
console.log('Slept!');

console.log('Sleeping+for+5+seconds...')
sleep(5000);
console.log('Slept!');|code-block|syntax|javascript|1838522|1838523|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/API/WindowTimers/setTimeout|1|https://developer.mozilla.org/en-US/docs/Web/API/WindowTimers/setInterval^0|0|Q|A|0|11|B|1|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|10|8|@]|9|@$D|11|E|12|1|13]|$D|14|E|15|1|16]]|A|$]]|$1|F|3|G|5|6|7|17|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|18|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|19|8|@]|9|@]|A|$M|N]]|$1|O|3|I|5|6|7|1A|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|Q|$R|$5|S|T|U|A|$V|W]]|X|$5|S|T|U|A|$V|Y]]]]

To summarize (like it has been said in previous answers):
There is no built-in sleep function in JavaScript. You should use <a href="https://developer.mozilla.org/en-US/docs/Web/API/WindowTimers/setTimeout" rel="nofollow noreferrer">setTimeout</a> or <a href="https://developer.mozilla.org/en-US/docs/Web/API/WindowTimers/setInterval" rel="nofollow noreferrer">setInterval</a> to achieve a similar effect.
If you really wanted to, you could simulate sleep functionality with a for loop such as the one shown in the original question, but that would make your CPU work like crazy. Inside a Web Worker an alternative solution would be to make a synchronous <code>XMLHttpRequest</code> to a non-responsive IP address and set a proper timeout. This would avoid the CPU utilization problem. Here's a code example:
<div class="snippet" data-lang="js" data-hide="false" data-console="false" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>// Works only inside a web worker

function sleep(milliseconds) {
 var req = new XMLHttpRequest();
 req.open("GET", "http://192.0.2.0/", false);
 req.timeout = milliseconds;
 try {
 req.send();
 } catch (ex) {

 }
}

console.log('Sleeping for 1 second...');
sleep(1000);
console.log('Slept!');

console.log('Sleeping for 5 seconds...')
sleep(5000);
console.log('Slept!');</code></pre>
</div>
</div>

blocks|key|2052746|text|这是2009年的一个老问题。现在，在2015年，一个新的解决方案成为可能，在ECMAScript+2015+AKA+ES6中定义了生成器。它在2015年6月获得批准，但之前在Firefox和Chrome中实现过。现在，休眠函数可以成为非繁忙、非阻塞和嵌套在循环和子函数中的函数，而不会冻结浏览器。只需要纯JavaScript+-不需要库或框架。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2052747|下面的程序展示了如何制作sleep()和runSleepyTask()。sleep()函数只是一条yield语句。这非常简单，实际上直接编写yield语句比调用sleep()更容易，但这样就没有休眠字了:-)+yield将一个时间值返回给wakeup()中的next()方法并等待。实际的“睡眠”是在wakeup()中使用好的旧setTimeout()完成的。在回调时，next()方法触发yield语句继续执行，而yield的“魔力”在于所有局部变量及其周围的整个调用堆栈仍然完好无损。|offset|length|style|CODE|2052748|必须将使用sleep()或yield的函数定义为生成器。只需向关键字function*添加星号即可轻松完成此操作。执行一个生成器有点棘手。当使用关键字new调用生成器时，生成器将返回一个具有next()方法的对象，但生成器的主体不会被执行(关键字new是可选的，没有任何区别)。next()方法触发生成器主体的执行，直到它遇到yield。包装器函数runSleepyTask()启动乒乓：next()等待yield，yield等待next()。|2052749|调用生成器的另一种方法是使用关键字yield*，在这里它的工作方式类似于简单的函数调用，但它还包括返回到next()的能力。|2052750|示例drawTree()演示了这一切。它在旋转的3D场景中绘制了一棵带有树叶的树。一棵树被画成树干，在顶部有三个不同方向的部分。然后，在短暂休眠之后，通过递归调用drawTree()，将每个部分绘制为另一个较小的树。一棵非常小的树被画成一片树叶。|2052751|在从runSleepyTask()开始的单独任务中，每个叶都有自己的生命。它在growLeaf()中诞生、成长、静坐、消逝、消亡。速度由sleep()控制。这演示了如何轻松地完成多任务。|2052752|​|2052753|function*+sleep(milliseconds)+{yield+milliseconds};

function+runSleepyTask(task)+{
++++(function+wakeup()+{
++++++++var+result+=+task.next();
++++++++if+(!result.done)+setTimeout(wakeup,+result.value);
++++})()
}
////////////////+written+by+Ole+Middelboe++/////////////////////////////

pen3D+=setup3D();
var+taskObject+=+new+drawTree(pen3D.center,+5);
runSleepyTask(taskObject);

function*+drawTree(root3D,+size)+{
++++if+(size+<+2)+runSleepyTask(new+growLeaf(root3D))
++++else+{
++++++++pen3D.drawTrunk(root3D,+size);
++++++++for+(var+p+of+[1,+3,+5])+{
++++++++++++var+part3D+=+new+pen3D.Thing;
++++++++++++root3D.add(part3D);
++++++++++++part3D.move(size).turn(p).tilt(1-p/20);
++++++++++++yield*+sleep(50);
++++++++++++yield*+drawTree(part3D,+(0.7%2Bp/40)*size);
++++++++}
++++}
}

function*+growLeaf(stem3D)+{
++++var+leaf3D+=+pen3D.drawLeaf(stem3D);
++++for+(var+s=0;s%2B%2B<15;)+{yield*+sleep(100);+leaf3D.scale.multiplyScalar(1.1)}
++++yield*+sleep(+1000+%2B+9000*Math.random()+);
++++for+(var+c=0;c%2B%2B<30;)+{yield*+sleep(200);+leaf3D.skin.color.setRGB(c/30,+1-c/40,+0)}
++++for+(var+m=0;m%2B%2B<90;)+{yield*+sleep(+50);+leaf3D.turn(0.4).tilt(0.3).move(2)}
++++leaf3D.visible+=+false;
}
///////////////////////////////////////////////////////////////////////

function+setup3D()+{
++++var+scene,+camera,+renderer,+diretionalLight,+pen3D;

++++scene+=+new+THREE.Scene();
++++camera+=+new+THREE.PerspectiveCamera(75,
++++++++window.innerWidth+/+window.innerHeight,+0.1,+1000);
++++camera.position.set(0,+15,+20);
++++renderer+=+new+THREE.WebGLRenderer({+alpha:+true,+antialias:+true+});
++++renderer.setSize(window.innerWidth,+window.innerHeight);
++++document.body.appendChild(renderer.domElement);

++++directionalLight+=+new+THREE.DirectionalLight(0xffffaa,+0.7);
++++directionalLight.position.set(-1,+2,+1);
++++scene.add(directionalLight);
++++scene.add(new+THREE.AmbientLight(0x9999ff));

++++(function+render()+{
++++++++requestAnimationFrame(render);
++++++++//+renderer.setSize(+window.innerWidth,+window.innerHeight+);
++++++++scene.rotateY(10/60/60);
++++++++renderer.render(scene,+camera);
++++})();

++++window.addEventListener(
++++++++'resize',
++++++++function(){
++++++++++++renderer.setSize(+window.innerWidth,+window.innerHeight+);
++++++++++++camera.aspect+=+window.innerWidth+/+window.innerHeight;
++++++++++++camera.updateProjectionMatrix();
+++++++},
+++++++false
++++);

++++pen3D+=+{
++++++++drawTrunk:+function(root,+size)+{
++++++++++++//+root.skin+=+skin(0.5,+0.3,+0.2);
++++++++++++root.add(new+THREE.Mesh(new+THREE.CylinderGeometry(size/12,+size/10,+size,+16),
++++++++++++++++root.skin).translateY(size/2));
++++++++++++root.add(new+THREE.Mesh(new+THREE.SphereGeometry(size/12,+16),
++++++++++++++++root.skin).translateY(size));
++++++++++++return+root;
++++++++},

++++++++drawLeaf:+function(stem)+{
++++++++++++stem.skin.color.setRGB(0,+1,+0);
++++++++++++stem.add(new+THREE.Mesh(new+THREE.CylinderGeometry(0,+0.02,+0.6),
++++++++++++++++stem.skin)+.rotateX(0.3).translateY(0.3));
++++++++++++stem.add(new+THREE.Mesh(new+THREE.CircleGeometry(0.2),
++++++++++++++++stem.skin)+.rotateX(0.3).translateY(0.4));
++++++++++++return+stem;
++++++++},

++++++++Thing:+function()+{
++++++++++++THREE.Object3D.call(this);
++++++++++++this.skin+=+new+THREE.MeshLambertMaterial({
++++++++++++++++color:+new+THREE.Color(0.5,+0.3,+0.2),
++++++++++++++++vertexColors:+THREE.FaceColors,
++++++++++++++++side:+THREE.DoubleSide
++++++++++++})
++++++++}
++++};

++++pen3D.Thing.prototype+=+Object.create(THREE.Object3D.prototype);
++++pen3D.Thing.prototype.tilt+=+pen3D.Thing.prototype.rotateX;
++++pen3D.Thing.prototype.turn+=+pen3D.Thing.prototype.rotateY;
++++pen3D.Thing.prototype.move+=+pen3D.Thing.prototype.translateY;

++++pen3D.center+=+new+pen3D.Thing;
++++scene.add(pen3D.center);

++++return+pen3D;
}|code-block|syntax|javascript|2052754|<script+src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r71/three.min.js"></script>|2052755|2052756|3D内容隐藏在setup3D()中，包含它只是为了使它不像console.log()那么乏味。顺便说一句，角度是用弧度来测量的。|2052757|经过测试，可以在Firefox和Chrome中工作。在Internet+Explore和iOS+(iPads)中未实现。试着自己运行它。|2052758|在我找到另一个答案后，加布里埃尔·拉特纳在一年前做出了类似的回答，to+。|2052759|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/951021/what-is-the-javascript-version-of-sleep/24401317#24401317^0|0|C|7|K|F|10|7|1D|5|1Y|5|28|7|3B|8|3L|6|46|8|4K|C|55|6|5F|5|0|Y|9|23|3|2N|6|3F|3|3V|6|4J|5|4U|F|5E|6|5M|5|5S|5|5Z|6|0|H|6|1G|6|0|2|A|29|A|0|2|F|13|A|1W|7|0|0|0|0|0|0|0|X|3|0|0^^$0|@$1|2|3|4|5|6|7|1D|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1E|8|@$D|1F|E|1G|F|G]|$D|1H|E|1I|F|G]|$D|1J|E|1K|F|G]|$D|1L|E|1M|F|G]|$D|1N|E|1O|F|G]|$D|1P|E|1Q|F|G]|$D|1R|E|1S|F|G]|$D|1T|E|1U|F|G]|$D|1V|E|1W|F|G]|$D|1X|E|1Y|F|G]|$D|1Z|E|20|F|G]|$D|21|E|22|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|23|8|@$D|24|E|25|F|G]|$D|26|E|27|F|G]|$D|28|E|29|F|G]|$D|2A|E|2B|F|G]|$D|2C|E|2D|F|G]|$D|2E|E|2F|F|G]|$D|2G|E|2H|F|G]|$D|2I|E|2J|F|G]|$D|2K|E|2L|F|G]|$D|2M|E|2N|F|G]|$D|2O|E|2P|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|2Q|8|@$D|2R|E|2S|F|G]|$D|2T|E|2U|F|G]]|9|@]|A|$]]|$1|L|3|M|5|6|7|2V|8|@$D|2W|E|2X|F|G]|$D|2Y|E|2Z|F|G]]|9|@]|A|$]]|$1|N|3|O|5|6|7|30|8|@$D|31|E|32|F|G]|$D|33|E|34|F|G]|$D|35|E|36|F|G]]|9|@]|A|$]]|$1|P|3|Q|5|6|7|37|8|@]|9|@]|A|$]]|$1|R|3|S|5|T|7|38|8|@]|9|@]|A|$U|V]]|$1|W|3|X|5|T|7|39|8|@]|9|@]|A|$U|V]]|$1|Y|3|Q|5|6|7|3A|8|@]|9|@]|A|$]]|$1|Z|3|10|5|6|7|3B|8|@]|9|@]|A|$]]|$1|11|3|12|5|6|7|3C|8|@]|9|@]|A|$]]|$1|13|3|14|5|6|7|3D|8|@]|9|@$D|3E|E|3F|1|3G]]|A|$]]|$1|15|3|-4|5|6|7|3H|8|@]|9|@]|A|$]]]|16|$17|$5|18|19|1A|A|$1B|1C]]]]

An old question from 2009. Now in 2015 a new solution is possible with generators defined in ECMAScript 2015 AKA ES6. It was approved in June 2015, but it was implemented in Firefox and Chrome before. Now a sleep function can be made non-busy, non-blocking and nested inside loops and sub-functions without freezing the browser. Only pure JavaScript is needed - no libraries or frameworks.
The program below shows how <code>sleep()</code> and <code>runSleepyTask()</code> can be made. The <code>sleep()</code> function is only a <code>yield</code> statement. It is so simple that it is actually easier to write the <code>yield</code> statement directly in stead of calling <code>sleep()</code>, but then there would be no sleep-word :-) The yield returns a time value to the <code>next()</code> method inside <code>wakeup()</code> and waits. The actual &quot;sleeping&quot; is done in <code>wakeup()</code> using the good old <code>setTimeout()</code>. At callback the the <code>next()</code> method triggers the <code>yield</code> statement to continue, and the &quot;magic&quot; of yield is that all the local variables and the whole call-stack around it is still intact.
Functions that use sleep() or yield must be defined as generators. It is easily done by adding an asterisk to the keyword <code>function*</code>. To execute a generator is a bit trickier. When invoked with the keyword <code>new</code> the generator returns an object that has the <code>next()</code> method, but the body of the generator is not executed (the keyword <code>new</code> is optional and makes no difference). The <code>next()</code> method triggers execution of the generator body until it encounters a <code>yield</code>. The wrapper function <code>runSleepyTask()</code> starts up the ping-pong: <code>next()</code> waits for a <code>yield</code>, and <code>yield</code> waits a <code>next()</code>.
Another way to invoke a generator is with keyword <code>yield*</code>, here it works like a simple function call, but it also includes the ability to yield back to <code>next()</code>.
This is all demonstrated by the example <code>drawTree()</code>. It draws a tree with leaves on a rotating 3D scene. A tree is drawn as a trunk with 3 parts at the top in different directions. Each part is then drawn as another but smaller tree by calling <code>drawTree()</code> recursively after a short sleep. A very small tree is drawn as only a leaf.
Each leaf has its own life in a separate task started with <code>runSleepyTask()</code>. It is born, grows, sits, fades, falls and dies in <code>growLeaf()</code>. The speed is controlled with <code>sleep()</code>. This demonstrates how easy multitasking can be done.
<div class="snippet" data-lang="js" data-hide="false" data-console="false" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>function* sleep(milliseconds) {yield milliseconds};

function runSleepyTask(task) {
 (function wakeup() {
 var result = task.next();
 if (!result.done) setTimeout(wakeup, result.value);
 })()
}
//////////////// written by Ole Middelboe /////////////////////////////

pen3D =setup3D();
var taskObject = new drawTree(pen3D.center, 5);
runSleepyTask(taskObject);

function* drawTree(root3D, size) {
 if (size &lt; 2) runSleepyTask(new growLeaf(root3D))
 else {
 pen3D.drawTrunk(root3D, size);
 for (var p of [1, 3, 5]) {
 var part3D = new pen3D.Thing;
 root3D.add(part3D);
 part3D.move(size).turn(p).tilt(1-p/20);
 yield* sleep(50);
 yield* drawTree(part3D, (0.7+p/40)*size);
 }
 }
}

function* growLeaf(stem3D) {
 var leaf3D = pen3D.drawLeaf(stem3D);
 for (var s=0;s++&lt;15;) {yield* sleep(100); leaf3D.scale.multiplyScalar(1.1)}
 yield* sleep( 1000 + 9000*Math.random() );
 for (var c=0;c++&lt;30;) {yield* sleep(200); leaf3D.skin.color.setRGB(c/30, 1-c/40, 0)}
 for (var m=0;m++&lt;90;) {yield* sleep( 50); leaf3D.turn(0.4).tilt(0.3).move(2)}
 leaf3D.visible = false;
}
///////////////////////////////////////////////////////////////////////

function setup3D() {
 var scene, camera, renderer, diretionalLight, pen3D;

 scene = new THREE.Scene();
 camera = new THREE.PerspectiveCamera(75,
 window.innerWidth / window.innerHeight, 0.1, 1000);
 camera.position.set(0, 15, 20);
 renderer = new THREE.WebGLRenderer({ alpha: true, antialias: true });
 renderer.setSize(window.innerWidth, window.innerHeight);
 document.body.appendChild(renderer.domElement);

 directionalLight = new THREE.DirectionalLight(0xffffaa, 0.7);
 directionalLight.position.set(-1, 2, 1);
 scene.add(directionalLight);
 scene.add(new THREE.AmbientLight(0x9999ff));

 (function render() {
 requestAnimationFrame(render);
 // renderer.setSize( window.innerWidth, window.innerHeight );
 scene.rotateY(10/60/60);
 renderer.render(scene, camera);
 })();

 window.addEventListener(
 'resize',
 function(){
 renderer.setSize( window.innerWidth, window.innerHeight );
 camera.aspect = window.innerWidth / window.innerHeight;
 camera.updateProjectionMatrix();
 },
 false
 );

 pen3D = {
 drawTrunk: function(root, size) {
 // root.skin = skin(0.5, 0.3, 0.2);
 root.add(new THREE.Mesh(new THREE.CylinderGeometry(size/12, size/10, size, 16),
 root.skin).translateY(size/2));
 root.add(new THREE.Mesh(new THREE.SphereGeometry(size/12, 16),
 root.skin).translateY(size));
 return root;
 },

 drawLeaf: function(stem) {
 stem.skin.color.setRGB(0, 1, 0);
 stem.add(new THREE.Mesh(new THREE.CylinderGeometry(0, 0.02, 0.6),
 stem.skin) .rotateX(0.3).translateY(0.3));
 stem.add(new THREE.Mesh(new THREE.CircleGeometry(0.2),
 stem.skin) .rotateX(0.3).translateY(0.4));
 return stem;
 },

 Thing: function() {
 THREE.Object3D.call(this);
 this.skin = new THREE.MeshLambertMaterial({
 color: new THREE.Color(0.5, 0.3, 0.2),
 vertexColors: THREE.FaceColors,
 side: THREE.DoubleSide
 })
 }
 };

 pen3D.Thing.prototype = Object.create(THREE.Object3D.prototype);
 pen3D.Thing.prototype.tilt = pen3D.Thing.prototype.rotateX;
 pen3D.Thing.prototype.turn = pen3D.Thing.prototype.rotateY;
 pen3D.Thing.prototype.move = pen3D.Thing.prototype.translateY;

 pen3D.center = new pen3D.Thing;
 scene.add(pen3D.center);

 return pen3D;
}</code></pre>
<pre class="snippet-code-html lang-html prettyprint-override"><code>&lt;script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r71/three.min.js"&gt;&lt;/script&gt;</code></pre>
</div>
</div>

The 3D stuff is hidden inside setup3D() and is only included to make it less boring than console.log(). Angles are measured in radians by the way.
Tested to work in Firefox and Chrome. Not implemented in Internet Explore and iOS (iPads). Try to run it yourself.
After another pass of the answers I found, that Gabriel Ratener made a similar answer a year ago <a href="https://stackoverflow.com/questions/951021/what-is-the-javascript-version-of-sleep/24401317#24401317">to What is the JavaScript version of sleep()?</a>.

blocks|key|1838724|text|有一个新的库，Sequencr.js，它巧妙地将函数与超时链接在一起，这样你就可以避免回调地狱。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1838725|它会变成这样：|1838726|setTimeout(function(timeout){
++++function1();
++++setTimeout(function(timeout){
++++++++function2();
++++++++setTimeout(function(timeout){
++++++++++++function3();
++++++++},+timeout,+timeout)
++++},+timeout,+timeout)
},+10,+10);|code-block|syntax|javascript|1838727|如下所示：|1838728|Sequencr.chain([function1,+function2,+function3],+10);|1838729|并内置了对在每次迭代之间“休眠”的循环的支持。|1838730|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/JSideris/Sequencr.js/wiki^0|7|B|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|6|7|12|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|13|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|C|$]]|$1|M|3|N|5|H|7|15|8|@]|9|@]|C|$I|J]]|$1|O|3|P|5|6|7|16|8|@]|9|@]|C|$]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]]]

There's a new library, <a href="https://github.com/JSideris/Sequencr.js/wiki" rel="nofollow noreferrer">Sequencr.js</a>, that neatly chains functions together with timeouts so you can avoid callback hell.
It turns this:
<pre><code>setTimeout(function(timeout){
 function1();
 setTimeout(function(timeout){
 function2();
 setTimeout(function(timeout){
 function3();
 }, timeout, timeout)
 }, timeout, timeout)
}, 10, 10);
</code></pre>
into this:
<pre><code>Sequencr.chain([function1, function2, function3], 10);
</code></pre>
And has built-in support for loops that &quot;sleep&quot; between each iteration.

blocks|key|1838763|text|另一种可能的方法是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1838764|var+_timer;
clearTimeout(_timer);
_timer+=+setTimeout(function()+{
++++//+Your+code
},+1000);+//+Delay+for+1+s.|code-block|syntax|javascript|1838765|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Another possible way is:

<pre><code>var _timer;
clearTimeout(_timer);
_timer = setTimeout(function() {
 // Your code
}, 1000); // Delay for 1 s.
</code></pre>

blocks|key|2053101|text|我浏览了一天的解决方案，但我仍然在考虑如何在使用回调时保持链接性。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2053102|每个人都熟悉传统的编程风格，即以同步的方式逐行运行代码。SetTimeout使用回调，因此下一行不会等待它完成。这让我思考如何让它“同步”，从而实现“睡眠”功能。|2053103|从一个简单的协程开始：|2053104|function+coroutine()+{
++++console.log('coroutine-1:start');
++++sleepFor(3000);+//+Sleep+for+3+seconds+here
++++console.log('coroutine-2:complete');
}|code-block|syntax|javascript|2053105|我想在中间休眠3秒，但我不想主宰整个流程，所以协程必须由另一个线程执行。我考虑了Unity+YieldInstruction，并在下面修改了协程：|offset|length|2053106|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%2B%2B;
}

var+c1+=+new+coroutine1();|2053107|声明sleepFor原型：|2053108|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(/%5E[\s\S]*?sleepFor[\s\S]*?yield;%7C}[\s;]*$/g,'');
++++var+context+=+this;
++++setTimeout(function()+{
++++++++new+Function(funcArgs,+funcBody).apply(context,+args);
++++},+ms);
++++return+this;
}|2053109|在运行coroutine1之后(我在in+11和Chrome+49上测试过)，你会看到它在两个控制台语句之间休眠3秒。它保持了代码和传统风格一样的美观。|2053110|棘手的部分在sleepFor例程中。它将调用者函数体作为字符串读取，并将其分为两部分。去掉上面的部分，然后用下面的部分创建另一个函数。在等待指定的毫秒数后，它通过应用原始上下文和参数来调用创建的函数。对于原始流，它将像往常一样以"return“结束。为了“收益”吗？它用于正则表达式匹配。这是必要的，但没有任何用处。|2053111|它并不是100%25完美的，但它至少完成了我的工作。我不得不提到使用这段代码的一些限制。由于代码被分成两部分，"return“语句必须在外部，而不是在任何循环或{}中。即|2053112|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%2B%2B;
}|2053113|上面的代码肯定有问题，因为在创建的函数中不能单独存在右括号。另一个限制是"var+xxx=123“声明的所有局部变量都不能传递到下一个函数。您必须使用"this.xxx=123“来实现相同的功能。如果你的函数有参数，并且它们发生了变化，那么修改后的值也不能传递到下一个函数。|2053114|function+coroutine4(x)+{+//+Assume+x=abc
++++var+z+=+x;
++++x+=+'def';
++++console.log('coroutine4-1:start'+%2B+z+%2B+x);+//+z=abc,+x=def
++++return+sleepFor(3000).yield;
++++console.log('coroutine4-2:'+%2B+z+%2B+x);+//+z=undefined,+x=abc
}|2053115|我将介绍另一个函数原型:+waitFor|2053116|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(/%5E[\s\S]*?waitFor[\s\S]*?yield;%7C}[\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;
}|2053117|它等待"check“函数，直到它返回true。它每100毫秒检查一次该值。你可以通过传递额外的参数来调整它。考虑一下测试coroutine2：|2053118|function+coroutine2(c)+{
++++/*+Some+code+here+*/
++++this.a+=+1;
++++console.log('coroutine2-1:'+%2B+this.a%2B%2B);
++++return+sleepFor(500).yield;

++++/*+Next+*/
++++console.log('coroutine2-2:'+%2B+this.a%2B%2B);
++++console.log('coroutine2-2:waitFor+c.a>100:'+%2B+c.a);
++++return+waitFor(function()+{
++++++++return+c.a>100;
++++}).yield;

++++/*+The+rest+of+the+code+*/
++++console.log('coroutine2-3:'+%2B+this.a%2B%2B);
}|2053119|同样是我们到目前为止喜欢的漂亮风格。实际上，我讨厌嵌套的回调。很容易理解，coroutine2将等待coroutine1的完成。有意思的?好的，然后运行以下代码：|2053120|this.a+=+10;
console.log('outer-1:'+%2B+this.a%2B%2B);
var+c1+=+new+coroutine1();
var+c2+=+new+coroutine2(c1);
console.log('outer-2:'+%2B+this.a%2B%2B);|2053121|输出为：|2053122|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|2053123|在初始化coroutine1和coroutine2之后，Outer会立即完成。然后，coroutine1将等待3000毫秒。Coroutine2将在等待500ms后进入第二步。之后，一旦检测到coroutine1.a值>+100，它将继续执行步骤3。|2053124|请注意，有三个上下文来保存变量"a“。一个是outer，值是10和11。另一个是coroutine1，值是100和101。最后一个是在coroutine2中，它的值是1,2和3。在coroutine2中，它也会等待来自coroutine1的c.a，直到它的值大于100。3个上下文是独立的。|2053125|复制和粘贴的完整代码：|2053126|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(/%5E[\s\S]*?sleepFor[\s\S]*?yield;%7C}[\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(/%5E[\s\S]*?waitFor[\s\S]*?yield;%7C}[\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%2B%2B;
}

function+coroutine2(c)+{
++++/*+Some+code+here+*/
++++this.a+=+1;
++++console.log('coroutine2-1:'+%2B+this.a%2B%2B);
++++return+sleepFor(500).yield;

++++/*+next+*/
++++console.log('coroutine2-2:'+%2B+this.a%2B%2B);
++++console.log('coroutine2-2:waitFor+c.a>100:'+%2B+c.a);
++++return+waitFor(function()+{
++++++++return+c.a>100;
++++}).yield;

++++/*+The+rest+of+the+code+*/
++++console.log('coroutine2-3:'+%2B+this.a%2B%2B);
}

this.a+=+10;
console.log('outer-1:'+%2B+this.a%2B%2B);
var+c1+=+new+coroutine1();
var+c2+=+new+coroutine2(c1);
console.log('outer-2:'+%2B+this.a%2B%2B);|2053127|它在Internet+Explorer+11和Chrome+49上进行了测试。因为它使用arguments.callee，所以如果它在严格模式下运行可能会有麻烦。|2053128|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.unity3d.com/ScriptReference/WaitForSeconds.html^0|0|0|0|0|14|M|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|24|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|25|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|26|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|27|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|28|8|@]|9|@$M|29|N|2A|1|2B]]|A|$]]|$1|O|3|P|5|H|7|2C|8|@]|9|@]|A|$I|J]]|$1|Q|3|R|5|6|7|2D|8|@]|9|@]|A|$]]|$1|S|3|T|5|H|7|2E|8|@]|9|@]|A|$I|J]]|$1|U|3|V|5|6|7|2F|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|2G|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|2H|8|@]|9|@]|A|$]]|$1|10|3|11|5|H|7|2I|8|@]|9|@]|A|$I|J]]|$1|12|3|13|5|6|7|2J|8|@]|9|@]|A|$]]|$1|14|3|15|5|H|7|2K|8|@]|9|@]|A|$I|J]]|$1|16|3|17|5|6|7|2L|8|@]|9|@]|A|$]]|$1|18|3|19|5|H|7|2M|8|@]|9|@]|A|$I|J]]|$1|1A|3|1B|5|6|7|2N|8|@]|9|@]|A|$]]|$1|1C|3|1D|5|H|7|2O|8|@]|9|@]|A|$I|J]]|$1|1E|3|1F|5|6|7|2P|8|@]|9|@]|A|$]]|$1|1G|3|1H|5|H|7|2Q|8|@]|9|@]|A|$I|J]]|$1|1I|3|1J|5|6|7|2R|8|@]|9|@]|A|$]]|$1|1K|3|1L|5|H|7|2S|8|@]|9|@]|A|$I|J]]|$1|1M|3|1N|5|6|7|2T|8|@]|9|@]|A|$]]|$1|1O|3|1P|5|6|7|2U|8|@]|9|@]|A|$]]|$1|1Q|3|1R|5|6|7|2V|8|@]|9|@]|A|$]]|$1|1S|3|1T|5|H|7|2W|8|@]|9|@]|A|$I|J]]|$1|1U|3|1V|5|6|7|2X|8|@]|9|@]|A|$]]|$1|1W|3|-4|5|6|7|2Y|8|@]|9|@]|A|$]]]|1X|$1Y|$5|1Z|20|21|A|$22|23]]]]

I navigated the solutions for a day, but I am still thinking about how to maintain the chainability in using a callback.
Everyone is familiar with the traditional programming style which is running the code line by line in a synchronised way. SetTimeout uses a callback so the next line does not wait for it to complete. This lets me think how to make it &quot;sync&quot;, so as to make a &quot;sleep&quot; function.
Beginning with a simple coroutine:
<pre><code>function coroutine() {
 console.log('coroutine-1:start');
 sleepFor(3000); // Sleep for 3 seconds here
 console.log('coroutine-2:complete');
}
</code></pre>
I want to sleep 3 seconds in the middle, but I don't want to dominate the whole flow, so the coroutine must be executed by another thread. I consider the <a href="http://docs.unity3d.com/ScriptReference/WaitForSeconds.html" rel="nofollow noreferrer">Unity YieldInstruction</a>, and modify the coroutine in the following:
<pre><code>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();
</code></pre>
Declare the sleepFor prototype:
<pre><code>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;
}
</code></pre>
After running the coroutine1 (I tested in Internet Explorer 11 and Chrome 49), you will see it sleep 3 seconds between two console statements. It keeps the codes as pretty as the traditional style.
The tricky bit is in sleepFor routine. It reads the caller function body as string and break it into two parts. Remove the upper part and create another function by lower part. After waiting for the specified number of milliseconds, it calls the created function by applying the original context and arguments. For the original flow, it will end by &quot;return&quot; as usual. For the &quot;yield&quot;? It is used for regular expression matching. It is necessary but no use at all.
It is not 100% perfect at all, but it achieves my jobs at least. I have to mention some limitations in using this piece of codes. As the code is being broken into two parts, the &quot;return&quot; statement must be in outer, instead of in any loop or {}. i.e.
<pre><code>function coroutine3() {
 this.a = 100;
 console.log('coroutine3-1:start');
 if(true) {
 return sleepFor(3000).yield;
 } // &lt;- Raise an exception here
 console.log('coroutine3-2:complete');
 this.a++;
}
</code></pre>
The above code must have a problem as the close bracket could not exist individually in the created function. Another limitation is all local variables declared by &quot;var xxx=123&quot; could not carry to the next function. You must use &quot;this.xxx=123&quot; to achieve the same thing. If your function has arguments and they got changes, the modified value also could not carry to the next function.
<pre><code>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
}
</code></pre>
I would introduce another function prototype: waitFor
<pre><code>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;
}
</code></pre>
It waits for &quot;check&quot; function until it returns true. It checks the value every 100 ms. You can adjust it by passing additional argument. Consider the testing coroutine2:
<pre><code>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&gt;100:' + c.a);
 return waitFor(function() {
 return c.a&gt;100;
 }).yield;

 /* The rest of the code */
 console.log('coroutine2-3:' + this.a++);
}
</code></pre>
Also in the pretty style we love so far. Actually I hate the nested callback. It is easily understood that the coroutine2 will wait for the completion of coroutine1. Interesting? Ok, then run the following code:
<pre><code>this.a = 10;
console.log('outer-1:' + this.a++);
var c1 = new coroutine1();
var c2 = new coroutine2(c1);
console.log('outer-2:' + this.a++);
</code></pre>
The output is:
<pre class="lang-none prettyprint-override"><code>outer-1:10
coroutine1-1:start
coroutine2-1:1
outer-2:11
coroutine2-2:2
coroutine2-2:waitFor c.a&gt;100:100
coroutine1-2:complete
coroutine2-3:3
</code></pre>
Outer is immediately completed after initialised coroutine1 and coroutine2. Then, coroutine1 will wait for 3000 ms. Coroutine2 will enter into step 2 after waited for 500 ms. After that, it will continue step 3 once it detects the coroutine1.a values &gt; 100.
Beware of that there are three contexts to hold variable &quot;a&quot;. One is outer, which values are 10 and 11. Another one is in coroutine1, which values are 100 and 101. The last one is in coroutine2, which values are 1,2 and 3. In coroutine2, it also waits for c.a which comes from coroutine1, until its value is greater than 100. 3 contexts are independent.
The whole code for copy&amp;paste:
<pre><code>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&gt;100:' + c.a);
 return waitFor(function() {
 return c.a&gt;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++);
</code></pre>
It is tested in Internet Explorer 11 and Chrome 49. Because it uses arguments.callee, so it may be trouble if it runs in strict mode.

blocks|key|2053291|text|如果你真的想暂停脚本，你可以这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2053292|var+milliseconds;
var+pretime;
var+stage;

function+step(time){
++switch(stage){
++++case+0:
++++++//Code+before+the+pause

++++++pretime=time;
++++++milliseconds=XXX;
++++++stage=1;
++++++break;
++++case+1:
++++++//Code+that+is+looped+through+while+paused

++++++if(time-pretime+>=+milliseconds){
++++++++//Code+after+the+pause

++++++++pretime=time;
++++++++milliseconds=XXX;
++++++++stage=2;
++++++}
++++++break;
++++case+2:
++++++//Code+that+is+looped+through+while+paused

++++++if(time-pretime+>=+milliseconds){
++++++++//Code+after+the+pause

++++++++pretime=time;
++++++++milliseconds=XXX;
++++++++stage=3;
++++++}
++++++break;
++++case+3:
++++++//Etc...
++}

++Window.requestAnimationFrame(step)
}

step();|code-block|syntax|javascript|2053293|这可能正是你想要的，如果你使用一个循环，你可以改变它的方式，使你有伪多线程，其中你有一些函数等待一段时间，而其他正常运行。我一直在纯JavaScript游戏中使用它。|2053294|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

If you really want to pause a script, you can do this:
<pre><code>var milliseconds;
var pretime;
var stage;

function step(time){
 switch(stage){
 case 0:
 //Code before the pause

 pretime=time;
 milliseconds=XXX;
 stage=1;
 break;
 case 1:
 //Code that is looped through while paused

 if(time-pretime &gt;= milliseconds){
 //Code after the pause

 pretime=time;
 milliseconds=XXX;
 stage=2;
 }
 break;
 case 2:
 //Code that is looped through while paused

 if(time-pretime &gt;= milliseconds){
 //Code after the pause

 pretime=time;
 milliseconds=XXX;
 stage=3;
 }
 break;
 case 3:
 //Etc...
 }

 Window.requestAnimationFrame(step)
}

step();
</code></pre>
This is probably exactly what you want if you use a loop anyway, and you can change it in ways so that you have pseudo-multi-threading, where you have some functions waiting a while and others running normally. I use this all the time for pure JavaScript games.

blocks|key|2053437|text|在LiveScript+(编译为JavaScript)中，您可以执行以下操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2053438|sleep+=+(ms,+func)+->+set-timeout+func,+ms

console.log+"hello-1"
<-+sleep+2000ms
console.log+"hello-2"
<-+sleep+2000ms
console.log+"hello-3"|code-block|syntax|javascript|2053439|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/LiveScript^0|1|A|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

In <a href="https://en.wikipedia.org/wiki/LiveScript" rel="nofollow noreferrer">LiveScript</a> (which compiles to JavaScript), you can do like the following:
<pre><code>sleep = (ms, func) -&gt; set-timeout func, ms

console.log &quot;hello-1&quot;
&lt;- sleep 2000ms
console.log &quot;hello-2&quot;
&lt;- sleep 2000ms
console.log &quot;hello-3&quot;
</code></pre>

blocks|key|2053493|text|这可能行得通。它适用于我在C和JavaScript中的工作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2053494|function+sleep(time)+{
++var+x+=+0;
++for(x+=+0;x+<+time;x%2B%2B)+{/*+Do+nothing+*/}
}|code-block|syntax|javascript|2053495|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This might work. It worked for me in C and JavaScript.
<pre><code>function sleep(time) {
 var x = 0;
 for(x = 0;x &lt; time;x++) {/* Do nothing */}
}
</code></pre>

blocks|key|2053555|text|借助await支持和bluebird+promise|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2053556|await+bluebird.delay(1000);|code-block|syntax|javascript|2053557|这将像C+language的同步sleep(1)一样工作。我最喜欢的解决方案。|2053558|entityMap|0|LINK|mutability|MUTABLE|url|http://bluebirdjs.com/docs/getting-started.html|1|https://en.wikipedia.org/wiki/C_%2528programming_language%2529^0|2|5|A|G|0|0|0|G|8|3|A|1|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@$9|Z|A|10|1|11]]|E|$]]|$1|F|3|G|5|H|7|12|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|13|8|@$9|14|A|15|B|C]]|D|@$9|16|A|17|1|18]]|E|$]]|$1|M|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]|U|$5|P|Q|R|E|$S|V]]]]

With <code>await</code> support and <a href="http://bluebirdjs.com/docs/getting-started.html" rel="nofollow noreferrer">bluebird promise</a>:
<pre><code>await bluebird.delay(1000);
</code></pre>
This will work like a synchronous <code>sleep(1)</code> of the <a href="https://en.wikipedia.org/wiki/C_%28programming_language%29" rel="nofollow noreferrer">C language</a>. My favorite solution.

blocks|key|1839445|text|我个人喜欢简单的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1839446|function+sleep(seconds){
++++var+waitUntil+=+new+Date().getTime()+%2B+seconds*1000;
++++while(new+Date().getTime()+<+waitUntil)+
++++++++true;
}|code-block|syntax|javascript|1839447|然后：|1839448|sleep(2);+//+Sleeps+for+2+seconds|1839449|在p5.js中创建脚本时，我一直在使用它来创建假的加载时间。|offset|length|1839450|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Processing_(programming_language)#p5.js)^0|0|0|0|0|1|5|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|10|8|@]|9|@$M|11|N|12|1|13]]|A|$]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

I personally like the simple:
<pre><code>function sleep(seconds){
 var waitUntil = new Date().getTime() + seconds*1000;
 while(new Date().getTime() &lt; waitUntil) 
 true;
}
</code></pre>
then:
<pre><code>sleep(2); // Sleeps for 2 seconds
</code></pre>
I'm using it all the time to create fake load times while creating scripts in <a href="https://en.wikipedia.org/wiki/Processing_(programming_language)#p5.js" rel="nofollow noreferrer">p5.js</a>.

blocks|key|2053764|text|这会帮到你的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2053765|var+reloadAfter+=+10;+//seconds
var+intervalId+=+setTimeout(function()+{
++++//code+you+want+to+execute+after+the+time+waiting
},+reloadAfter+*+1000);+//+60000+=+60+sec+=+1+min|code-block|syntax|javascript|2053766|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This will do you the trick.

<pre><code>var reloadAfter = 10; //seconds
var intervalId = setTimeout(function() {
 //code you want to execute after the time waiting
}, reloadAfter * 1000); // 60000 = 60 sec = 1 min
</code></pre>

blocks|key|2053833|text|我已经有这个问题很长一段时间了，我需要的答案并不完全是这里提供的。此等待功能会导致同步等待，而不会占用CPU。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2053834|函数waitForIt向anywhere发出Ajax请求，并将async标志设置为false。函数waitF对帧执行相同的操作，函数waitD对div执行相同的操作。Ajax大约需要100ms，frame大约是25，div大约是1。|2053835|等待函数根据您给予它的时间来利用所有这些。如果等待的时间不够长，那么再做一次。|2053836|在处理多个异步加载元素时，我需要这个。基本上是“等到这个元素存在”。你可以在https://jsfiddle.net/h2vm29ue/上试用它。它只是利用了浏览器自然等待的东西。更长的版本https://jsfiddle.net/5cov1p0z/32/更精确。|offset|length|2053837|+function+waitForIt()+{
+++++var+start+=+new+Date();
+++++var+xhttp+=+new+XMLHttpRequest();
+++++xhttp.onreadystatechange+=+function()+{
+++++++++if+(this.readyState+==+4+&&+this.status+==+200)+{
++++++++++++//+Doesn't+matter
+++++++++}
+++++};
+++++xhttp.open("GET",+"WaitForIt",+false);
+++++xhttp.send();
+++++var+end+=+new+Date();
+}
+//

+function+waitF()+{
+++++var+start+=+new+Date();
+++++var+ifram+=+document.createElement('iframe');
+++++ifram.id+=+'ifram';
+++++ifram.src+=+'';
+++++var+div+=+document.createElement('div');
+++++div.id+=+'timer';
+++++document.body.appendChild(div);
+++++document.getElementById('timer').appendChild(ifram);
+++++document.getElementById('timer').removeChild(ifram);
+++++document.body.removeChild(div);
+++++var+end+=+new+Date();
+++++return+(end+-+start);
+}


+function+waitD()+{
+++++var+start+=+new+Date();
+++++var+div+=+document.createElement('div');
+++++div.id+=+'timer';
+++++document.body.appendChild(div);
+++++div.click();
+++++document.body.removeChild(div);
+++++var+end+=+new+Date();
+++++return+(end+-+start);
+}

+function+wait(time)+{
+++++var+start+=+new+Date();
+++++var+end+=+new+Date();
+++++while+((end+-+start+<+time))+{

+++++++++if+((time+-+(end+-+start))+>=+200)+{
+++++++++++++waitForIt();
+++++++++}+else+{
+++++++++++++if+((time+-+(end+-+start))+>=+50)+{
+++++++++++++++++waitF();
+++++++++++++}+else+{
+++++++++++++++++waitD();
+++++++++++++}
+++++++++}
+++++++++end+=+new+Date();
+++++}
+++++return+(end+-+start);
+}|code-block|syntax|javascript|2053838|entityMap|0|LINK|mutability|MUTABLE|url|https://jsfiddle.net/h2vm29ue/|1|https://jsfiddle.net/5cov1p0z/32/^0|0|0|0|12|U|0|2N|X|1|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|11|8|@]|9|@$H|12|I|13|1|14]|$H|15|I|16|1|17]]|A|$]]|$1|J|3|K|5|L|7|18|8|@]|9|@]|A|$M|N]]|$1|O|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]|W|$5|R|S|T|A|$U|X]]]]

I have had this question for a long time and the answer I needed was not exactly what has been provided here. This wait function causes a synchronous wait that does not tie up the CPU.
Function waitForIt makes an Ajax request to anywhere and sets the async flag to false. Function waitF does the same with a frame and function waitD does the same with a div. Ajax takes about 100 ms, frame is about 25, and div is about 1.
The wait function leverages all of these depending on how much time you give it. If it didn't wait long enough then do it again.
I need this when dealing with multiple asynchronous loading elements. Basically for 'wait until this element exists'. You can play with it at <a href="https://jsfiddle.net/h2vm29ue/" rel="nofollow noreferrer">https://jsfiddle.net/h2vm29ue/</a>. It just leverages the things that the browser naturally waits for. The longer version, <a href="https://jsfiddle.net/5cov1p0z/32/" rel="nofollow noreferrer">https://jsfiddle.net/5cov1p0z/32/</a>, is more precise.
<pre><code> function waitForIt() {
 var start = new Date();
 var xhttp = new XMLHttpRequest();
 xhttp.onreadystatechange = function() {
 if (this.readyState == 4 &amp;&amp; this.status == 200) {
 // Doesn't matter
 }
 };
 xhttp.open(&quot;GET&quot;, &quot;WaitForIt&quot;, false);
 xhttp.send();
 var end = new Date();
 }
 //

 function waitF() {
 var start = new Date();
 var ifram = document.createElement('iframe');
 ifram.id = 'ifram';
 ifram.src = '';
 var div = document.createElement('div');
 div.id = 'timer';
 document.body.appendChild(div);
 document.getElementById('timer').appendChild(ifram);
 document.getElementById('timer').removeChild(ifram);
 document.body.removeChild(div);
 var end = new Date();
 return (end - start);
 }


 function waitD() {
 var start = new Date();
 var div = document.createElement('div');
 div.id = 'timer';
 document.body.appendChild(div);
 div.click();
 document.body.removeChild(div);
 var end = new Date();
 return (end - start);
 }

 function wait(time) {
 var start = new Date();
 var end = new Date();
 while ((end - start &lt; time)) {

 if ((time - (end - start)) &gt;= 200) {
 waitForIt();
 } else {
 if ((time - (end - start)) &gt;= 50) {
 waitF();
 } else {
 waitD();
 }
 }
 end = new Date();
 }
 return (end - start);
 }
</code></pre>

blocks|key|1839692|text|一个用于休眠的函数，使用同步调用让操作系统执行此操作。使用您喜欢的任何操作系统睡眠命令。从使用CPU时间的意义上来说，它并不忙于等待。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1839693|我选择了ping一个不存在的地址。|1839694|const+cp+=+require('child_process');

function+sleep(ms)
{
++++try{cp.execSync('ping+192.0.2.0+-n+1+-w+'%2Bms);}
++++catch(err){}
}|code-block|syntax|javascript|1839695|一个测试来验证它是否正常工作|1839696|console.log(Date.now());
console.log(Date.now());
sleep(10000);
console.log(Date.now());
console.log(Date.now());|1839697|还有一些测试结果。|1839698|1491575275136
1491575275157|1839699|(+10秒后)|1839700|1491575285075
1491575285076|1839701|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

A function to sleep, using a synchronous call to let the OS do it. Use any OS sleep command you like. It is not busy waiting in the sense of using CPU time.
I chose ping on a non-existent address.
<pre><code>const cp = require('child_process');

function sleep(ms)
{
 try{cp.execSync('ping 192.0.2.0 -n 1 -w '+ms);}
 catch(err){}
}
</code></pre>
A test to verify it works
<pre><code>console.log(Date.now());
console.log(Date.now());
sleep(10000);
console.log(Date.now());
console.log(Date.now());
</code></pre>
And some test results.
<pre><code>1491575275136
1491575275157
</code></pre>
(and after 10 seconds)
<pre><code>1491575285075
1491575285076
</code></pre>

blocks|key|2054063|text|到目前为止，我读到的每个解决方案都是这样的：“让我们睡觉吧，看看明天会发生什么”。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2054064|setInterval(callback，time)会等待很长时间，然后调用回调，同时阻塞运行时。"setInterval“的当前实现远不是线程保存的，甚至不是并发的。|2054065|虽然上面提到的稀疏解决方案看起来像C#+(笑)，但它们仍然不像C#/.NET那样工作，它们仍然像C+#那样工作。|2054066|JavaScript目前没有提供实现真正的多线程的架构。最好的方法是TypeScript，但这仍然缺乏真正的解决方案，以至于它...很痛。JavaScript、jQuery、AJAX、jNode，甚至TypeScript都是一群依赖于实现者情绪好坏的追求者。事实。句号。|2054067|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

Each and every solution I've read so far would be like &quot;let's get to sleep and look what happened, tomorrow&quot;.
setInterval(callback, time) would wait time long and then call the callback, while blocking the runtime. The current implementation of &quot;setInterval&quot; is far from being thread-save, not even to mind concurrency.
While the sparse solutions mentioned look like, guess what, C# (laughs), they still don't work like in C#/.NET. They still work like in C.
JavaScript currently does not provide an architecture to accomplish real multi-threading. The best approach would be TypeScript, but still this lacks so much of a real solution that it... hurts. JavaScript, and jQuery, and AJAX, and jNode, and even TypeScript are just a bunch of wannabes relying on the goods and bads of the moods of the implementers. Fact. Full stop.

blocks|key|2054142|text|要使主线程繁忙几毫秒，请执行以下操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2054143|function+wait(ms)+{
++const+start+=+performance.now();
++while(performance.now()+-+start+<+ms);
}|code-block|syntax|javascript|2054144|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

To keep the main thread busy for some milliseconds:

<pre><code>function wait(ms) {
 const start = performance.now();
 while(performance.now() - start &lt; ms);
}
</code></pre>

blocks|key|1840127|text|现在还可以使用本机模块util来提供常规同步功能。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1840128|const+{+promisify+}+=+require('util')
const+sleep+=+promisify(setTimeout)

module.exports+=+()+=>+{
++await+someAsyncFunction()
++await+sleep(2000)
++console.log('2+seconds+later...')
}|code-block|syntax|javascript|1840129|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

It is now also possible to use the native module util to promisify regular sync functions.

<pre><code>const { promisify } = require('util')
const sleep = promisify(setTimeout)

module.exports = () =&gt; {
 await someAsyncFunction()
 await sleep(2000)
 console.log('2 seconds later...')
}
</code></pre>

blocks|key|2054341|text|从+7.6开始，您可以将utils模块中的promisify函数与setTimeout结合使用。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2054342|const+sleep+=+require('util').promisify(setTimeout)|code-block|syntax|javascript|2054343|一般用法|2054344|async+function+main()+{
++++console.time("Slept+for")
++++await+sleep(3000)
++++console.timeEnd("Slept+for")
}

main()|2054345|问题用法|2054346|async+function+asyncGenerator()+{
++++while+(goOn)+{
++++++var+fileList+=+await+listFiles(nextPageToken);
++++++await+sleep(3000)
++++++var+parents+=+await+requestParents(fileList);
++++}
++}|2054347|entityMap^0|L|9|X|A|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|12|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|S|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|T|$]]

Since <a href="https://en.wikipedia.org/wiki/Node.js" rel="nofollow noreferrer">Node.js</a> 7.6, you can combine the <code>promisify</code> function from the utils module with <code>setTimeout</code>.
<pre><code>const sleep = require('util').promisify(setTimeout)
</code></pre>
<h2>General Usage</h2>
<pre><code>async function main() {
 console.time(&quot;Slept for&quot;)
 await sleep(3000)
 console.timeEnd(&quot;Slept for&quot;)
}

main()
</code></pre>
<h2>Question Usage</h2>
<pre><code>async function asyncGenerator() {
 while (goOn) {
 var fileList = await listFiles(nextPageToken);
 await sleep(3000)
 var parents = await requestParents(fileList);
 }
 }
</code></pre>

blocks|key|1840277|text|我也遇到过类似的问题，必须等待控件的存在，然后每隔一段时间签入。由于在JavaScript中没有真正的睡眠、等待或暂停，并且在Internet+Explorer中不支持等待/异步，所以我使用setTimeOut并在成功找到元素的情况下插入函数来解决这个问题。下面是完整的示例代码，因此每个人都可以在自己的项目中复制和使用它：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1840278|<html>
<head>
++++<script+src="https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
++++<script+type="text/javascript">
++++++++var+ElementSearchStatus+=+{
++++++++++++None:+0,
++++++++++++Found:+1,
++++++++++++NotFound:+2,
++++++++++++Timeout:+3
++++++++};

++++++++var+maxTimeout+=+5;
++++++++var+timeoutMiliseconds+=+1000;

++++++++function+waitForElement(elementId,+count,+timeout,+onSuccessFunction)+{
++++++++++++%2B%2Bcount;
++++++++++++var+elementSearchStatus+=+existsElement(elementId,+count,+timeout);
++++++++++++if+(elementSearchStatus+==+ElementSearchStatus.None)+{
++++++++++++++++window.setTimeout(waitForElement,+timeoutMiliseconds,+elementId,+count,+timeout,+onSuccessFunction);
++++++++++++}
++++++++++++else+{
++++++++++++++++if+(elementSearchStatus+==+ElementSearchStatus.Found)+{
++++++++++++++++++++onSuccessFunction();
++++++++++++++++}
++++++++++++}
++++++++}

++++++++function+existsElement(elementId,+count,+timeout)+{
++++++++++++var+foundElements+=+$("#"+%2B+elementId);
++++++++++++if+(foundElements.length+>+0+%7C%7C+count+>+timeout)+{
++++++++++++++++if+(foundElements.length+>+0)+{
++++++++++++++++++++console.log(elementId+%2B+"+found");
++++++++++++++++++++return+ElementSearchStatus.Found;
++++++++++++++++}
++++++++++++++++else+{
++++++++++++++++++++console.log("Search+for+"+%2B+elementId+%2B+"+timed+out+after+"+%2B+count+%2B+"+tries.");
++++++++++++++++++++return+ElementSearchStatus.Timeout;
++++++++++++++++}
++++++++++++}
++++++++++++else+{
++++++++++++++++console.log("waiting+for+"+%2B+elementId+%2B+"+after+"+%2B+count+%2B+"+of+"+%2B+timeout);
++++++++++++++++return+ElementSearchStatus.None;
++++++++++++}
++++++++}

++++++++function+main()+{
++++++++++++waitForElement("StartButton",+0,+maxTimeout,+function+()+{
++++++++++++++++console.log("found+StartButton!");
++++++++++++++++DoOtherStuff("StartButton2")
++++++++++++});
++++++++}

++++++++function+DoOtherStuff(elementId)+{
++++++++++++waitForElement(elementId,+0,+maxTimeout,+function+()+{
++++++++++++++++console.log("found+"+%2B+elementId);
++++++++++++++++DoOtherStuff("StartButton3");
++++++++++++});
++++++++}
++++</script>
</head>
<body>
++++<button+type="button"+id="StartButton"+onclick="main();">Start+Test</button>
++++<button+type="button"+id="StartButton2"+onclick="alert('Hey+ya+Start+Button+2');">Show+alert</button>
</body>
</html>|code-block|syntax|javascript|1840279|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I had a similar problem, having to wait for control existence and checking in intervals.
Since there is no real sleep, wait or pause in JavaScript and using await / async is not supported properly in Internet Explorer, I made a solution using setTimeOut and injecting the function in case of successfully finding the element.
Here is the complete sample code, so everyone can reproduce and use it for their own project:

<pre><code>&lt;html&gt;
&lt;head&gt;
 &lt;script src="https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/jquery.min.js"&gt;&lt;/script&gt;
 &lt;script type="text/javascript"&gt;
 var ElementSearchStatus = {
 None: 0,
 Found: 1,
 NotFound: 2,
 Timeout: 3
 };

 var maxTimeout = 5;
 var timeoutMiliseconds = 1000;

 function waitForElement(elementId, count, timeout, onSuccessFunction) {
 ++count;
 var elementSearchStatus = existsElement(elementId, count, timeout);
 if (elementSearchStatus == ElementSearchStatus.None) {
 window.setTimeout(waitForElement, timeoutMiliseconds, elementId, count, timeout, onSuccessFunction);
 }
 else {
 if (elementSearchStatus == ElementSearchStatus.Found) {
 onSuccessFunction();
 }
 }
 }

 function existsElement(elementId, count, timeout) {
 var foundElements = $("#" + elementId);
 if (foundElements.length &gt; 0 || count &gt; timeout) {
 if (foundElements.length &gt; 0) {
 console.log(elementId + " found");
 return ElementSearchStatus.Found;
 }
 else {
 console.log("Search for " + elementId + " timed out after " + count + " tries.");
 return ElementSearchStatus.Timeout;
 }
 }
 else {
 console.log("waiting for " + elementId + " after " + count + " of " + timeout);
 return ElementSearchStatus.None;
 }
 }

 function main() {
 waitForElement("StartButton", 0, maxTimeout, function () {
 console.log("found StartButton!");
 DoOtherStuff("StartButton2")
 });
 }

 function DoOtherStuff(elementId) {
 waitForElement(elementId, 0, maxTimeout, function () {
 console.log("found " + elementId);
 DoOtherStuff("StartButton3");
 });
 }
 &lt;/script&gt;
&lt;/head&gt;
&lt;body&gt;
 &lt;button type="button" id="StartButton" onclick="main();"&gt;Start Test&lt;/button&gt;
 &lt;button type="button" id="StartButton2" onclick="alert('Hey ya Start Button 2');"&gt;Show alert&lt;/button&gt;
&lt;/body&gt;
&lt;/html&gt;
</code></pre>

blocks|key|2054681|text|一种非常简单的进行睡眠的方法，它将与任何运行JavaScript的程序兼容…这段代码已经过大约500个条目的测试，CPU和内存使用情况在我的web浏览器上仍然不可见。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2054682|下面是一个等待节点变得可见的函数...|2054683|此函数创建新的上下文function+()+{}以避免递归。我们在这个新的上下文中放置了与调用者代码相同的代码。我们使用函数Timeout在几秒钟后调用我们的函数。|offset|length|style|CODE|2054684|var+get_hyper+=+function(node,+maxcount,+only_relation)+{
++++if+(node.offsetParent+===+null)+{
++++++++//+node+is+hidden
++++++++setTimeout(function+()+{+get_hyper(node,+maxcount,+only_relation)},+
+++++++++++++++++++1000);
++++++++return;
++++};

++++//+Enter+the+code+here+that+waits+for+that+node+becoming+visible
++++//+before+getting+executed.

};|code-block|syntax|javascript|2054685|entityMap^0|0|0|A|E|1Q|7|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|S|8|@$F|T|G|U|H|I]|$F|V|G|W|H|I]]|9|@]|A|$]]|$1|J|3|K|5|L|7|X|8|@]|9|@]|A|$M|N]]|$1|O|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|P|$]]

A very simple way to do do sleep, that will be compatible with anything that runs JavaScript... This code has been tested with something like 500 entries, and CPU and memory usage is still not visible on my web browsers.
Here is one function that waits until the node becomes visible...
This function creates a new context <code>function () {}</code> to avoid recursion. We placed code that does the same as the caller code inside this new context. We use the function <code>Timeout</code> to call our function after a few time second.
<pre><code>var get_hyper = function(node, maxcount, only_relation) {
 if (node.offsetParent === null) {
 // node is hidden
 setTimeout(function () { get_hyper(node, maxcount, only_relation)}, 
 1000);
 return;
 };

 // Enter the code here that waits for that node becoming visible
 // before getting executed.

};
</code></pre>

blocks|key|2054750|text|我得到的承诺不是使用顶部答案的构造函数。如果你导入了bluebird，你可以做到这一点。在我看来，这是最简单的解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2054751|import+*+as+Promise+from+'bluebird';

await+Promise.delay(5000)|code-block|syntax|javascript|2054752|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I got Promise is not a constructor using the top answer. If you import bluebird you can do this. It is the simplest solution, in my opinion.
<pre><code>import * as Promise from 'bluebird';

await Promise.delay(5000)
</code></pre>

blocks|key|1840587|text|使用实际休眠函数的问题是JavaScript是单线程的，休眠函数很可能会使浏览器选项卡在此期间挂起。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1840588|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

The problem with using an actual sleep function is that JavaScript is single-threaded and a sleep function will pretty much make your browser tab hang for that duration.

blocks|key|2054788|text|使用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2054789|​|2054790|++await+new+Promise(resolve+=>+setTimeout(resolve,+2000));|code-block|syntax|javascript|2054791|2054792|确保你的调用函数是异步的。这是经过验证的，并且工作正常。|2054793|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|P|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|R|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|M|$]]

Use:
<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code> await new Promise(resolve =&gt; setTimeout(resolve, 2000));</code></pre>
</div>
</div>

Make sure your calling function is async. This is verified and is working fine.

blocks|key|2054798|text|没有任何依赖关系的最短解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2054799|await+new+Promise(resolve+=>+setTimeout(resolve,+5000));|code-block|syntax|javascript|2054800|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The shortest solution without any dependencies:

<pre><code>await new Promise(resolve =&gt; setTimeout(resolve, 5000));
</code></pre>

blocks|key|2054833|text|你可以做这样的事情。所有函数都可以继承的睡眠方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2054834|​|2054835|Function.prototype.sleep+=+function(delay,+...args)+{
++++setTimeout(()+=>+this(...args),+delay)
}

console.log.sleep(2000,+'Hello,+World!!')|code-block|syntax|javascript|2054836|2054837|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

You could do something like this. A sleep method that all functions can inherit:
<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>Function.prototype.sleep = function(delay, ...args) {
 setTimeout(() =&gt; this(...args), delay)
}

console.log.sleep(2000, 'Hello, World!!')</code></pre>
</div>
</div>

blocks|key|2054892|text|在sleep方法中，您可以返回任何可执行的对象。而不一定是一个新的承诺。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2054893|示例：|2054894|​|2054895|const+sleep+=+(t)+=>++({+then:+(r)+=>+setTimeout(r,+t)+})

const+someMethod+=+async+()+=>+{

++++console.log("hi");
++++await+sleep(5000)
++++console.log("bye");
}

someMethod()|code-block|syntax|javascript|2054896|2054897|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|P|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|Q|8|@]|9|@]|A|$I|J]]|$1|K|3|E|5|6|7|R|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|M|$]]

In the sleep method you can return any then-able object. And not necessarily a new promise.
Example:
<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const sleep = (t) =&gt; ({ then: (r) =&gt; setTimeout(r, t) })

const someMethod = async () =&gt; {

 console.log("hi");
 await sleep(5000)
 console.log("bye");
}

someMethod()</code></pre>
</div>
</div>

blocks|key|2055014|text|2021%2B更新|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2055015|如果您正在寻找以下替代方案：|2055016|let+sleep+=+ms+=>+new+Promise(res=>setTimeout(res,ms));|code-block|syntax|javascript|2055017|然后使用以下命令：|2055018|let+sleep+=+async+ms+=>+void+await+Atomics.waitAsync(new+Int32Array(new+SharedArrayBuffer(4)),+0,+0,+ms).value;|2055019|请注意，在发布此问题时，它是第3阶段的提案。此外，它可能要求您的站点是跨域隔离的。要查看它是否能在您的浏览器中工作，(在Stack+Overflow上)尝试以下命令：|2055020|​|2055021|let+sleep+=+async+ms+=>+void+await+Atomics.waitAsync(new+Int32Array(new+SharedArrayBuffer(4)),+0,+0,+ms).value;

void+async+function()+{
++console.log(1);
++await+sleep(2000);
++console.log(2);
}()|2055022|2055023|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|X|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|Y|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|Z|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|10|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|11|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|S|3|P|5|6|7|13|8|@]|9|@]|A|$]]|$1|T|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|U|$]]

<h2>2021+ Update</h2>
If you are looking for an alternative to:
<pre class="lang-js prettyprint-override"><code>let sleep = ms =&gt; new Promise(res=&gt;setTimeout(res,ms));
</code></pre>
Then use this:
<pre><code>let sleep = async ms =&gt; void await Atomics.waitAsync(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms).value;
</code></pre>
Note, that as of when this question is posted, it is a Stage 3 proposal. Also, it may require your site to be cross-origin isolated. To see if it works in your browser, (on Stack Overflow) try this:
<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>let sleep = async ms =&gt; void await Atomics.waitAsync(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms).value;

void async function() {
 console.log(1);
 await sleep(2000);
 console.log(2);
}()</code></pre>
</div>
</div>

blocks|key|2055148|text|JavaScript是一个单线程执行环境。每个函数都只由一个线程执行。请求“休眠”意味着您希望将整个VM实例暂停许多(毫秒)，我认为这在JavaScript世界中不是一个非常现实的要求，因为如果正在执行的线程处于休眠状态，那么不仅是这个特定的函数，而且所有其他的执行都会受到影响。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2055149|首先，实际上不可能让该线程休眠。你只能通过什么都不做的工作来让线程保持忙碌。但是，如果您只想在某些计算中添加延迟，请将它们的执行放在单个函数上下文中，并让延续发生在该函数中的setTimeout+(或Promise，如果您愿意)中。如果通过睡眠，你希望延迟一些事情，否则，这是不可能的。|2055150|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

JavaScript is a single-threaded execution environment. Every function out there is getting executed by just one thread. Asking for a &quot;sleep&quot; means you want to halt the whole VM instance for those many (milli)seconds, which I don't think is a very realistic ask in the JavaScript world, as not only that particular function, but the rest of all executions suffer if the executing thread is made to sleep.
First of all, it is not possible to actually sleep that thread. You can only try to keep that thread busy by putting into some work doing no thing. However, if you want to only add a delay in some computation(s), put their executions inside a single function context, and let the continuation happen inside a setTimeout (or a Promise, if you prefer) from within that function. If by sleep, you are looking to delay something, otherwise, it's not possible.

blocks|key|1840939|text|require('deasync').sleep(100);|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1840940|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>require('deasync').sleep(100);
</code></pre>

blocks|key|2055255|text|如果你真的需要等待那么多秒，目前被接受的使用async/await和setTimeout的解决方案是完美的。但是，如果您将其用于屏幕上的动画，则应该真正使用requestAnimationFrame()。这与setTimeout的功能非常相似，但是只有当动画对用户可见时，才会调用回调。这意味着，如果你在你的网站上运行一个动画，用户切换标签，动画将暂停并节省电池寿命。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2055256|下面是一个使用requestAnimationFrame的wait方法的实现。它接收多个帧，并在它们都通过后进行解析：|2055257|​|2055258|const+animationWait+=+(frames)+=>+
++new+Promise((resolve)+=>+{
++++let+framesPassed+=+0;
++++requestAnimationFrame(function+loop()+{
++++++if+(%2B%2BframesPassed+>=+frames)+return+resolve();
++++++requestAnimationFrame(loop);
++++});
++});
++
//+typewriter+effect+for+demonstration
const+content+=+document.querySelector(".content");

async+function+typeWriter(endText,+wait)+{
++content.textContent+=+"";
++for+(const+letter+of+endText)+{
++++content.textContent+%2B=+letter;
++++await+animationWait(wait);
++}
}

typeWriter("Okay.+This+simple+typewriter+effect+is+an+example+of+requestAnimationFrame.",+8);|code-block|syntax|javascript|2055259|
++The+animation+will+play+below;+Try+switching+tabs+and+see+that+++
++the+animation+pauses.

<code+class="content"></code>|2055260|2055261|Read+more+about+requestAnimationFrame|2055262|Browser+support+(IE10%2B)|2055263|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/API/window/requestAnimationFrame|1|https://caniuse.com/?search=requestanimationframe^0|M|B|Y|A|26|N|2W|A|0|7|L|T|4|0|0|0|0|0|G|L|0|11|0|0|0|N|1|0^^$0|@$1|2|3|4|5|6|7|15|8|@$9|16|A|17|B|C]|$9|18|A|19|B|C]|$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1E|8|@$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|1J|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|1K|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|L|7|1L|8|@]|D|@]|E|$M|N]]|$1|Q|3|I|5|6|7|1M|8|@]|D|@]|E|$]]|$1|R|3|S|5|6|7|1N|8|@$9|1O|A|1P|B|C]]|D|@$9|1Q|A|1R|1|1S]]|E|$]]|$1|T|3|U|5|6|7|1T|8|@]|D|@$9|1U|A|1V|1|1W]]|E|$]]|$1|V|3|-4|5|6|7|1X|8|@]|D|@]|E|$]]]|W|$X|$5|Y|Z|10|E|$11|12]]|13|$5|Y|Z|10|E|$11|14]]]]

The currently accepted solution of using <code>async/await</code> and <code>setTimeout</code> is perfect if you need to really wait that many seconds. If you are using it for on-screen animations, however, you should really be using <code>requestAnimationFrame()</code>. This functions very similarly to <code>setTimeout</code>, but the callback is only called when the animation is visible to the user. That means that if you're running an animation on your site and the user switches tabs, the animation will pause and save battery life.
Here's an implementation of the <code>wait</code> method using <code>requestAnimationFrame</code>. It takes in a number of frames and resolves once they have all passed:
<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const animationWait = (frames) =&gt; 
 new Promise((resolve) =&gt; {
 let framesPassed = 0;
 requestAnimationFrame(function loop() {
 if (++framesPassed &gt;= frames) return resolve();
 requestAnimationFrame(loop);
 });
 });
 
// typewriter effect for demonstration
const content = document.querySelector(".content");

async function typeWriter(endText, wait) {
 content.textContent = "";
 for (const letter of endText) {
 content.textContent += letter;
 await animationWait(wait);
 }
}

typeWriter("Okay. This simple typewriter effect is an example of requestAnimationFrame.", 8);</code></pre>
<pre class="snippet-code-html lang-html prettyprint-override"><code>&lt;p&gt;
 The animation will play below; Try switching tabs and see that 
 the animation pauses.
&lt;/p&gt;
&lt;code class="content"&gt;&lt;/code&gt;</code></pre>
</div>
</div>

<a href="https://developer.mozilla.org/en-US/docs/Web/API/window/requestAnimationFrame" rel="nofollow noreferrer">Read more about <code>requestAnimationFrame</code></a>
<a href="https://caniuse.com/?search=requestanimationframe" rel="nofollow noreferrer">Browser support (IE10+)</a>

blocks|key|2055322|text|这是睡眠的阻塞版本。发现在需要顺序执行的测试活动中更容易遵循。可以像sleep(2000)一样调用它来让线程休眠2秒。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2055323|function+sleep(ms)+{
++++const+now+=+Date.now();
++++const+limit+=+now+%2B+ms;
++++let+execute+=+true;
++++while+(execute)+{
++++++++if+(limit+<+Date.now())+{
++++++++++++execute+=+false;
++++++++}
++++}
++++return;
++}|code-block|syntax|javascript|2055324|entityMap^0|Y|B|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

This is a blocking version of sleep. Found it easier to follow during testing activities where you need sequential execution. It can be called like <code>sleep(2000)</code> to sleep the thread for 2 seconds.
<pre><code>function sleep(ms) {
 const now = Date.now();
 const limit = now + ms;
 let execute = true;
 while (execute) {
 if (limit &lt; Date.now()) {
 execute = false;
 }
 }
 return;
 }
</code></pre>

blocks|key|1841195|text|简单地说，您可以使用与pausecomp函数相同的while循环来实现sleep()+(这基本上是相同的)：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1841196|const+sleep+=+(seconds)+=>+{
++++const+waitUntil+=+new+Date().getTime()+%2B+seconds+*+1000
++++while(new+Date().getTime()+<+waitUntil)+{
++++++++//+do+nothing
++++}
}|code-block|syntax|javascript|1841197|您可以像这样使用sleep()方法：|1841198|const+main+=+()+=>+{
++++const+a+=+1+%2B+3

++++//+Sleep+3+seconds+before+the+next+action
++++sleep(3)
++++const+b+=+a+%2B+4

++++//+Sleep+4+seconds+before+the+next+action
++++sleep(4)
++++const+c+=+b+%2B+5
}

main()|1841199|这就是我想您使用睡眠功能的方式，并且相对简单易懂。我借用了另一篇文章中的Sleep+in+JavaScript+-+delay+between+actions来展示你可能打算如何使用它。|1841200|不幸的是，您的计算机将变得过热，所有工作将被阻止。如果在浏览器中运行，选项卡将停止，用户将无法与页面交互。|1841201|如果您将代码重构为异步的，那么您可以像其他post一样利用setTimeout()作为休眠函数。|1841202|//+define+sleep+using+setTimeout
const+sleep+=+(seconds,+callback)+=>+setTimeout(()+=>+callback(),+seconds+*+1000)

const+main+=+()+=>+{
++++const+a+=+1+%2B+3
++++let+b+=+undefined
++++let+c+=+undefined

++++//+Sleep+3+seconds+before+the+next+action
++++sleep(3,+()+=>+{
++++++++b+=+a+%2B+4

++++++++//+Sleep+4+seconds+before+the+next+action
++++++++sleep(4,+()+=>+{
++++++++++++c+=+b+%2B+5
++++++++})
++++})
}

main()|1841203|如你所说，这不是你想要的。我修改了Sleep+in+JavaScript+-+delay+between+actions中的示例，以说明为什么会出现这种情况。当您添加更多操作时，您将需要将逻辑放入单独的函数中，或者将代码嵌套得越来越深(callback+hell)。|1841204|为了解决“回调地狱”，我们可以使用promises来定义睡眠：|1841205|const+sleep+=+(seconds)+=>+new+Promise((resolve+=>+setTimeout(()+=>+resolve(),+seconds+*+1000)))

const+main+=+()+=>+{
++++const+a+=+1+%2B+3
++++let+b+=+undefined
++++let+c+=+undefined

++++//+Sleep+3+seconds+before+the+next+action
++++return+sleep(3)
++++++++.then(()+=>+{
++++++++++++b+=+a+%2B+4

++++++++++++//+Sleep+4+seconds+before+the+next+action
++++++++++++return+sleep(4)
++++++++})
++++++++.then(()+=>+{
++++++++++++c+=+b+%2B+5
++++++++})
}

main()|1841206|Promises可以避免深度嵌套，但看起来仍然不像我们开始时使用的常规同步代码。我们希望编写看起来同步的代码，但没有任何缺点。|1841207|让我们使用async/await重新编写我们的main方法|1841208|const+sleep+=+(seconds)+=>+new+Promise((resolve+=>+setTimeout(()+=>+resolve(),+seconds+*+1000)))

const+main+=+async+()+=>+{
++++const+a+=+1+%2B+3

++++//+Sleep+3+seconds+before+the+next+action
++++await+sleep(3)
++++const+b+=+a+%2B+4

++++//+Sleep+4+seconds+before+the+next+action
++++await+sleep(4)
++++const+c+=+b+%2B+5
}

main()|1841209|使用async/await，我们几乎可以像调用同步阻塞函数一样调用sleep()。这解决了你在其他post的回调解决方案中可能遇到的问题，并避免了长时间运行的循环问题。|1841210|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/758688/sleep-in-javascript-delay-between-actions|1|https://developer.mozilla.org/en-US/docs/Web/API/setTimeout|2|3|https://developer.mozilla.org/en-US/docs/Learn/JavaScript/Asynchronous/Choosing_the_right_approach|4|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise|5|https://developer.mozilla.org/en-US/docs/Learn/JavaScript/Asynchronous/Async_await^0|Z|7|0|0|8|7|0|0|10|17|0|0|0|T|C|1|0|0|H|17|2|3A|D|3|0|H|8|4|0|0|0|5|B|5|0|0|X|7|0^^$0|@$1|2|3|4|5|6|7|1R|8|@$9|1S|A|1T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1U|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1V|8|@$9|1W|A|1X|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|1Y|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1Z|8|@]|D|@$9|20|A|21|1|22]]|E|$]]|$1|Q|3|R|5|6|7|23|8|@]|D|@]|E|$]]|$1|S|3|T|5|6|7|24|8|@]|D|@$9|25|A|26|1|27]]|E|$]]|$1|U|3|V|5|H|7|28|8|@]|D|@]|E|$I|J]]|$1|W|3|X|5|6|7|29|8|@]|D|@$9|2A|A|2B|1|2C]|$9|2D|A|2E|1|2F]]|E|$]]|$1|Y|3|Z|5|6|7|2G|8|@]|D|@$9|2H|A|2I|1|2J]]|E|$]]|$1|10|3|11|5|H|7|2K|8|@]|D|@]|E|$I|J]]|$1|12|3|13|5|6|7|2L|8|@]|D|@]|E|$]]|$1|14|3|15|5|6|7|2M|8|@]|D|@$9|2N|A|2O|1|2P]]|E|$]]|$1|16|3|17|5|H|7|2Q|8|@]|D|@]|E|$I|J]]|$1|18|3|19|5|6|7|2R|8|@$9|2S|A|2T|B|C]]|D|@]|E|$]]|$1|1A|3|-4|5|6|7|2U|8|@]|D|@]|E|$]]]|1B|$1C|$5|1D|1E|1F|E|$1G|1H]]|1I|$5|1D|1E|1F|E|$1G|1J]]|1K|$5|1D|1E|1F|E|$1G|1H]]|1L|$5|1D|1E|1F|E|$1G|1M]]|1N|$5|1D|1E|1F|E|$1G|1O]]|1P|$5|1D|1E|1F|E|$1G|1Q]]]]

Naively, you can implement <code>sleep()</code> with a while loop same as the pausecomp function (this is basically the same):
<pre class="lang-js prettyprint-override"><code>const sleep = (seconds) =&gt; {
 const waitUntil = new Date().getTime() + seconds * 1000
 while(new Date().getTime() &lt; waitUntil) {
 // do nothing
 }
}
</code></pre>
And you can use the <code>sleep()</code> method like so:
<pre class="lang-js prettyprint-override"><code>const main = () =&gt; {
 const a = 1 + 3

 // Sleep 3 seconds before the next action
 sleep(3)
 const b = a + 4

 // Sleep 4 seconds before the next action
 sleep(4)
 const c = b + 5
}

main()
</code></pre>
This is how I imagine you would use the sleep function, and is relatively straightforward to read. I borrowed from the other post <a href="https://stackoverflow.com/questions/758688/sleep-in-javascript-delay-between-actions">Sleep in JavaScript - delay between actions</a> to show how you may have been intending to use it.
Unfortunately, your computer will get warm and all work will be blocked. If running in a browser, the tab will grind to a halt and the user will be unable to interact with the page.
If you restructure your code to be asynchronous, then you can leverage <a href="https://developer.mozilla.org/en-US/docs/Web/API/setTimeout" rel="nofollow noreferrer">setTimeout()</a> as a sleep function same as the other post.
<pre class="lang-js prettyprint-override"><code>// define sleep using setTimeout
const sleep = (seconds, callback) =&gt; setTimeout(() =&gt; callback(), seconds * 1000)

const main = () =&gt; {
 const a = 1 + 3
 let b = undefined
 let c = undefined

 // Sleep 3 seconds before the next action
 sleep(3, () =&gt; {
 b = a + 4

 // Sleep 4 seconds before the next action
 sleep(4, () =&gt; {
 c = b + 5
 })
 })
}

main()
</code></pre>
As you said, this isn't what you wanted. I modified the example from <a href="https://stackoverflow.com/questions/758688/sleep-in-javascript-delay-between-actions">Sleep in JavaScript - delay between actions</a> to show why this might be. As you add more actions, you will either need to pull your logic into separate functions or nest your code deeper and deeper (<a href="https://developer.mozilla.org/en-US/docs/Learn/JavaScript/Asynchronous/Choosing_the_right_approach" rel="nofollow noreferrer">callback hell</a>).
To solve &quot;callback hell&quot;, we can define sleep using <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" rel="nofollow noreferrer">promises</a> instead:
<pre class="lang-js prettyprint-override"><code>const sleep = (seconds) =&gt; new Promise((resolve =&gt; setTimeout(() =&gt; resolve(), seconds * 1000)))

const main = () =&gt; {
 const a = 1 + 3
 let b = undefined
 let c = undefined

 // Sleep 3 seconds before the next action
 return sleep(3)
 .then(() =&gt; {
 b = a + 4

 // Sleep 4 seconds before the next action
 return sleep(4)
 })
 .then(() =&gt; {
 c = b + 5
 })
}

main()
</code></pre>
Promises can avoid the deep nesting, but still doesn't look like the regular synchronous code that we started with. We want to write code that looks synchronous, but doesn't have any of the downsides.
Let's rewrite our main method again using <a href="https://developer.mozilla.org/en-US/docs/Learn/JavaScript/Asynchronous/Async_await" rel="nofollow noreferrer">async/await</a>:
<pre class="lang-js prettyprint-override"><code>const sleep = (seconds) =&gt; new Promise((resolve =&gt; setTimeout(() =&gt; resolve(), seconds * 1000)))

const main = async () =&gt; {
 const a = 1 + 3

 // Sleep 3 seconds before the next action
 await sleep(3)
 const b = a + 4

 // Sleep 4 seconds before the next action
 await sleep(4)
 const c = b + 5
}

main()
</code></pre>
With async/await, we can call <code>sleep()</code> almost as if it was a synchronous, blocking function. This solves the problem you may have had with the callback solution from the other post and avoids issues with a long-running loop.

Is there a better way to engineer a <code>sleep</code> in JavaScript than the following <code>pausecomp</code> function (<a href="http://www.sean.co.uk/a/webdesign/javascriptdelay.shtm" rel="noreferrer">taken from here</a>)?

<pre><code>function pausecomp(millis)
{
 var date = new Date();
 var curDate = null;
 do { curDate = new Date(); }
 while(curDate-date &lt; millis);
}
</code></pre>

This is not a duplicate of <a href="https://stackoverflow.com/questions/758688/sleep-in-javascript-delay-between-actions">Sleep in JavaScript - delay between actions</a>; I want a real sleep in the middle of a function, and not a delay before a piece of code executes.

What is the JavaScript version of sleep()?

TypeScript

服务器

jQuery

HTML5

Java

有没有比下面的pausecomp函数()更好的在JavaScript中设计sleep的方法呢？function pausecomp(millis){    var date = new Date();    var curDate = null;    do { curDate = new Date(); }    w...

问JavaScript ()的睡眠版本是什么？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问JavaScript ()的睡眠版本是什么？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问JavaScript ()的睡眠版本是什么？
EN