实际上，您可以使用与pausecomp函数相同的while循环实现sleep（）（这基本上是相同的）：

const sleep = (seconds) => {
    const waitUntil = new Date().getTime() + seconds * 1000
    while(new Date().getTime() < waitUntil) {
        // do nothing
    }
}

您可以像这样使用sleep（）方法：

const main = () => {
    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()

这就是我想象你会使用睡眠功能的方式，而且读起来相对简单。我借鉴了另一篇文章《JavaScript中的睡眠——动作之间的延迟》，以展示您可能打算如何使用它。

不幸的是，你的电脑会变热，所有工作都会受阻。如果在浏览器中运行，该选项卡将停止，用户将无法与页面交互。

如果您将代码重组为异步的，那么您可以将setTimeout（）作为与其他文章相同的睡眠函数。

// define sleep using setTimeout
const sleep = (seconds, callback) => setTimeout(() => callback(), seconds * 1000)

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

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

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

main()

正如你所说，这不是你想要的。我修改了Sleep in JavaScript中的示例-动作之间的延迟，以说明为什么会出现这种情况。当您添加更多动作时，要么需要将逻辑拉入单独的函数，要么将代码嵌套得越来越深（回调地狱）。

为了解决“回调地狱”，我们可以使用promise来定义睡眠：

const sleep = (seconds) => new Promise((resolve => setTimeout(() => resolve(), seconds * 1000)))

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

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

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

main()

Promise可以避免深度嵌套，但看起来仍然不像我们最初使用的常规同步代码。我们希望编写看起来同步的代码，但没有任何缺点。

让我们再次使用async/await重写我们的主方法：

const sleep = (seconds) => new Promise((resolve => setTimeout(() => resolve(), seconds * 1000)))

const main = async () => {
    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()

使用async/await，我们可以调用sleep（），就好像它是一个同步的阻塞函数一样。这解决了您可能在其他帖子中使用回调解决方案时遇到的问题，并避免了长时间循环的问题。

我也搜索了一个睡眠解决方案（不用于生产代码，只用于开发和测试），并找到了这篇文章：

JavaScript sleep（）或wait（）

…还有一篇关于客户端解决方案的文章：JavaScript睡眠

此外，当您调用alert（）时，代码也会暂停，同时显示警报——您需要找到一种方法来不显示警报，但获得相同的效果。：）

require('deasync').sleep(100);

到目前为止，我读到的每一个解决方案都是“让我们睡觉，看看明天发生了什么”。

setInterval（callback，time）将等待很长时间，然后调用回调，同时阻塞运行时。“setInterval”的当前实现远非线程保存，甚至不考虑并发性。

虽然上面提到的稀疏解决方案看起来像，猜猜看，C#（笑），但它们仍然不像在C#/.NET中那样工作。

JavaScript目前没有提供实现真正多线程的架构。最好的方法是TypeScript，但这仍然缺乏太多真正的解决方案，以至于它……令人痛苦。JavaScript、jQuery、AJAX、jNode，甚至TypeScript都只是一群依赖于实现者心情好坏的人。事实句点

如果确实要暂停脚本，可以执行以下操作：

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

如果您使用循环，这可能正是您想要的，并且您可以以某种方式对其进行更改，从而获得伪多线程，其中一些函数等待一段时间，其他函数正常运行。我一直在纯JavaScript游戏中使用这个。

内联函数：

(async () => await new Promise(resolve => setTimeout(resolve, 500)))();

500是VM在移动到下一行代码之前等待的时间（以毫秒为单位）。

tldr位；

基本上，当您创建一个promise时，它会在创建时返回一个可观察到的值，在回调中提供一个解析引用，用于在数据/响应可用时移交数据/响应。在这里，在500ms后通过setTimeOut调用resolve，直到未执行resolve之前，外部作用域正在等待进一步的处理，因此，创建了一个伪块。这与非阻塞（或调用其他语言中可用的非线程保留睡眠）完全不同，因为线程和最可能的UI以及网页/节点应用程序的任何其他正在进行的任务将被阻塞，而主线程将专门用于等待承诺解决。