在Firebug（可能还有其他JavaScript控制台）中，只有在指定的睡眠时间（…）之后，点击enter后才会发生任何事情

function sleepFor(sleepDuration){
    var now = new Date().getTime();
    while(new Date().getTime() < now + sleepDuration){ /* Do nothing */ }
}

使用示例：

函数sleepFor（sleepDuration）{var now=new Date（）.getTime（）；而（newDate（）.getTime（）＜now+sleepDuration）｛/*什么都不做*/}}函数sleepThenAt（）{sleepFor（2000）；console.log（“您好，JavaScript睡眠！”）；}sleepThenAt（）

注：仅用于调试和开发

使用TypeScript：

这里有一个可以等待的快速sleep（）实现。这与上面的答案尽可能相似。它在功能上是等效的，除了ms被键入为TypeScript的数字。

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

async function demo() {
  console.log('Taking a break for 2s (2000ms)...');
  await sleep(2000);
  console.log('Two seconds later');
}

demo();

就这样。等待睡眠（＜持续时间＞）。

注意，

await只能在前缀为async关键字的函数中执行，或者在某些环境中在脚本的顶层执行（例如，Chrome DevTools控制台或Runkit）。await只暂停当前的异步函数。

首先，应该使用setTimeout和setInterval，因为JavaScript具有回调性质。如果您想使用sleep（），则是控制流或代码架构不正确。

尽管如此，我想我仍然可以帮助实现两个睡眠。

1.我头顶上的假同步跑步：

// A module to do that //dual-license: MIT or WTF [you can use it anyhow and leave my nickname in a comment if you want to]
var _ = (function(){
  var queue = [];
  var play = function(){
    var go = queue.shift();
      if(go) {
        if(go.a) {
          go.f();
          play();
        }
        else
        {
          setTimeout(play, go.t);
        }
      }
  }
  return {
    go:function(f){
      queue.push({a:1, f:f});
    },
    sleep:function(t){
      queue.push({a:0, t:t});
    },
    playback:play
  }
})();

[也可以自动播放]

// Usage

_.go(function(){

  // Your code
  console.log('first');

});

_.sleep(5000);

_.go(function(){

  // Your code
  console.log('next');

});

// This triggers the simulation
_.playback();

2.实际同步运行

有一天，我对它进行了很多思考，我在JavaScript中真正睡觉的唯一想法就是技术。

睡眠函数必须是同步Ajax调用，超时设置为睡眠值。这就是真正睡觉的唯一方法。

出于对$DEITY的热爱，请不要使用忙等待睡眠功能。setTimeout和setInterval可以满足您的需要。

var showHide=document.getElementById（'showHide'）；setInterval（（）=>{showHide.style.visibility=“初始”；setTimeout（（）=>{showHide.style.visibility=“隐藏”}, 1000);}, 2000); ＜div id=“showHide”＞您好！再见</分区>

每隔两秒隐藏文本一秒。这显示了如何使用setInterval和setTimeout每秒显示和隐藏文本。

这里的大多数答案都是错误的，或者至少是过时的。没有理由JavaScript必须是单线程的，事实上也不是。今天，所有主流浏览器都支持工人。在此之前，Rhino和Node.js等其他JavaScript运行时支持多线程。

“JavaScript是单线程的”不是有效答案。例如，在工作线程中运行睡眠函数不会阻止UI线程中运行的任何代码。

在支持生成器和yield的较新运行时中，可以在单线程环境中为sleep函数带来类似的功能：

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

这种对睡眠的模仿不同于真正的睡眠函数，因为它不会阻塞线程。它只是JavaScript当前setTimeout函数之上的糖。这种功能类型已经在Task.js中实现，现在应该可以在Firefox中使用。

可以使用带有递增较大值的闭包调用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