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

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

Edit

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

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

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

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

我有这个问题很久了，我需要的答案并不完全是这里提供的。此等待函数会导致同步等待，而不会占用CPU。

函数waitForIt向任何地方发出Ajax请求，并将异步标志设置为false。函数waitF对一个帧执行相同的操作，函数waitD对一个div执行相同的处理。Ajax大约需要100毫秒，frame大约是25，div大约是1。

wait函数根据您给它的时间来利用所有这些。如果它等待的时间不够长，请再次执行。

在处理多个异步加载元素时，我需要这个。基本上是“等待此元素存在”。你可以在https://jsfiddle.net/h2vm29ue/.它只是利用了浏览器自然等待的东西。较长的版本，https://jsfiddle.net/5cov1p0z/32/，更精确。

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

2017-2021更新

自2009年提出这个问题以来，JavaScript已经有了很大的发展。所有其他答案现在都过时或过于复杂。以下是当前的最佳实践：

function sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
}

或作为一个内衬：

await new Promise(r => setTimeout(r, 2000));

作为一项功能：

const sleep = ms => new Promise(r => setTimeout(r, ms));

或使用字体：

const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));

将其用作：

await sleep(<duration>);

演示：

功能睡眠（ms）{return new Promise（resol=>setTimeout（resolve，ms））；}异步函数demo（）{for（设i=0；i<5；i++）{console.log（`等待${i}秒…`）；等待睡眠（i*1000）；}console.log（'Done'）；}demo（）；

注意，

await只能在前缀为async关键字的函数中执行，或者在越来越多的环境中在脚本的顶层执行。await只暂停当前的异步函数。这意味着它不会阻止脚本的其余部分的执行，这在大多数情况下都是您想要的。如果您确实需要一个阻塞构造，请使用Atomics.wait查看这个答案，但请注意，大多数浏览器都不允许在浏览器的主线程上使用它。

两个新的JavaScript功能（截至2017年）帮助编写了这个“睡眠”函数：

Promises是ES2015（又称ES6）的原生功能。我们还在睡眠函数的定义中使用箭头函数。async/await特性允许代码显式地等待承诺（解决或拒绝）。

兼容性

承诺在Node v0.12+中得到支持，在浏览器中得到广泛支持，IE除外async/await登陆V8，自Chrome 55（2016年12月发布）以来默认启用它于2016年10月登陆Node 7并于2016年11月登陆Firefox Nightly

如果出于某种原因，您使用的Node早于7（已于2017年到期），或者针对的是旧浏览器，则仍可通过Babel（一种将JavaScript+新功能转换为普通旧JavaScript的工具）使用async/await，并使用将async-to-generator转换为生成器插件。

使用三种功能：

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

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

工具书类

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

在sleep方法中，可以返回任何可执行的对象。不一定是新的承诺。

例子：

constsleep=（t）=>（{then:（r）=>setTimeout（r，t）}）常量someMethod=async（）=>{console.log（“hi”）；等待睡眠（5000）console.log（“再见”）；}someMethod（）

一行使用Promise

const wait = t => new Promise(s => setTimeout(s, t, t));

带有中止信号的字体

const wait = (x: number, signal?: AbortSignal): Promise<number> => {
  return new Promise((s, f) => {
    const id = setTimeout(s, x, x);
    signal?.addEventListener('abort', () => {
      clearTimeout(id);
      f('AbortError');
    });
  });
};

Demo

const wait＝t＝＞new Promise（s＝＞setTimeout（s，t））；//用途异步函数demo（）{//倒计时设i=6；而（i-）{等待等待（1000）；控制台日志（i）；}//数字0到5的总和，延迟1秒constsum=await[…Array（6）.keys（）].reduce（async（a，b）=>{a=等待a；等待等待（1000）；常量结果=a+b；console.log（`${a}+${b}=${result}`）；返回结果；}，承诺.决议（0））；console.log（“sum”，总和）；}demo（）；