如果你写一个这样的睡眠函数

var sleep = function(period, decision, callback){
    var interval = setInterval(function(){
        if (decision()) {
            interval = clearInterval(interval);
            callback();
        }
    }, period);
}

你有一个异步函数可以多次调用，

var xhr = function(url, callback){
    // Make an Ajax request
    // Call a callback when the request fulfils
}

您的项目设置如下：

var ready = false;

function xhr1(){
    xhr(url1, function(){ ready = true;});
}
function xhr2(){
    xhr(url2, function(){ ready = true; });
}
function xhr3(){
    xhr(url3, function(){ ready = true; });
}

然后您可以执行以下操作：

xhr1();
sleep(100, function(){ return done; }, xhr2);
sleep(100, function(){ return done; }, xhr3);
sleep(100, function(){ return done; }, function(){
    // Do more
});

而不是像这样无休止的回调缩进：

xhr(url1, function(){
    xhr2(url2, function(){
        xhr3(url3, function(){
            // Do more
        });
    });
});

如果必须处理同步执行，我可以理解睡眠函数的用途。setInterval和setTimeout函数创建一个并行执行线程，该线程将执行序列返回到主程序，如果您必须等待给定的结果，这是无效的。当然，可以使用事件和处理程序，但在某些情况下，这不是预期的。

使用更好的DX实现更安全的异步睡眠

我使用睡眠进行调试。。。我忘了用wait太多次了。让我挠头。我在写下面的实时片段时忘记使用await。。。不再！

如果您在1毫秒内运行了两次，下面的睡眠功能会提醒您。如果您确定使用了await，它还支持传递一个相当的参数。它不会投掷，因此可以安全地用作睡眠的替代品。享受

是的，实时片段中有一个JavaScript版本。

// Sleep, with protection against accidentally forgetting to use await
export const sleep = (s: number, quiet?: boolean) => {
  const sleepId = 'SLEEP_' + Date.now()
  const G = globalThis as any
  if (G[sleepId] === true && !quiet) {
    console.error('Did you call sleep without await? use quiet to hide msg.')
  } else {
    G[sleepId] = true
  }
  return new Promise((resolve) => {
    !quiet && setTimeout(() => {
      delete G[sleepId]
    }, 1)
    setTimeout(resolve, (s * 1000) | 0)
  })
}

//睡眠，防止意外忘记使用等待常量睡眠=（s，安静）=>{constsleepId='SLEEP_'+Date.now（）const G=全局此if（G[sleepId]==true&&！quiet）{console.error（'您是否在没有等待的情况下调用sleep？使用quiet隐藏消息。'）}其他{G[sleepId]=真}return new Promise（（resolve）=>{!quiet&&setTimeout（（）=>{删除G[sleepId]}, 1)setTimeout（解析，（s*1000）|0）})}常量main=async（）=>{console.log（'休眠1秒…'）等待睡眠（1）console.log（'使用等待的目标…'）睡眠（99）睡眠（99）等待睡眠（1，true）console.log（“开发人员快乐！”）}main（）

与公认更容易阅读的相比：

const sleep = (s: number) =>
  new Promise((p) => setTimeout(p, (s * 1000) | 0))

一种可能需要sleep（）函数而不是使用setTimeout（）的情况是，如果您有一个响应用户单击的函数，最终将打开一个新的弹出窗口，并且您已经启动了一些处理，需要很短的时间才能完成弹出窗口的显示。将打开的窗口移动到关闭状态意味着它通常会被浏览器阻止。

第一：

定义要执行的函数，如下所示：

function alertWorld(){
  alert("Hello, World!");
}

然后使用setTimeout方法安排其执行：

setTimeout(alertWorld, 1000)

注意两件事

第二个参数是以毫秒为单位的时间作为第一个参数，必须只传递函数的名称（引用），而不传递括号

可以使用带有递增较大值的闭包调用setTimeout（）。

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

结果：

waited 0 milliseconds
function executed for item: item1
waited 2000 milliseconds
function executed for item: item2
waited 4000 milliseconds
function executed for item: item3