我有这个问题很久了，我需要的答案并不完全是这里提供的。此等待函数会导致同步等待，而不会占用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);
 }

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

例子：

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

我建议以前的python开发人员使用此方法

const sleep = (time) => {
   return new Promise((resolve) => setTimeout(resolve, Math.ceil(time * 1000)));
};

用法：

await sleep(10) // for 10 seconds

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

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

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

JavaScript是一个单线程执行环境。每个函数都只由一个线程执行。请求“休眠”意味着你想让整个VM实例停止那么多（毫秒），我认为这在JavaScript世界中不是一个非常现实的要求，因为如果执行线程休眠，那么不仅是特定的函数，所有其他执行都会受到影响。

首先，不可能真正休眠该线程。你只能通过不做任何事情的方式来让线程保持忙碌。但是，如果您只想在某些计算中添加延迟，请将它们的执行放在单个函数上下文中，并让继续发生在该函数中的setTimeout（或Promise，如果您愿意）中。如果通过睡眠，你想要延迟一些事情，否则，这是不可能的。

在服务器端，您可以使用deasync sleep（）方法，该方法在C中本地实现，因此它可以有效地实现等待效果，而不会阻塞事件循环或将CPU置于100%负载。

例子：

#!/usr/bin/env node

// Requires `npm install --save deasync`
var sleep = require("deasync").sleep;

sleep(5000);

console.log ("Hello World!!");

但是，如果您需要一个纯JavaScript函数（例如，通过浏览器在客户端运行它），我很抱歉地说，我认为您的pausecomp（）函数是实现它的唯一方法，而且，除此之外：

这不仅会暂停函数，还会暂停整个事件循环。因此，将不会参加其他活动。它使您的CPU处于100%负载。

因此，如果您需要它作为浏览器脚本，并且不希望出现这些可怕的效果，我必须说，您应该以某种方式重新思考您的功能：

a） 。您可以在超时时调用它（或调用do_the_rest（）函数）。如果您不期望从函数中得到任何结果，则使用更简单的方法。

b） 。或者，如果你需要等待结果，那么你应该使用promise（当然，也可以使用回调地狱；-））。

无预期结果示例：

function myFunc() {

    console.log ("Do some things");

    setTimeout(function doTheRest(){
        console.log ("Do more things...");
    }, 5000);

    // Returns undefined.
};

myFunc();

返回promise的示例（注意它会改变函数的用法）：

function myFunc(someString) {

    return new Promise(function(resolve, reject) {

        var result = [someString];
        result.push("Do some things");

        setTimeout(function(){
            result.push("Do more things...");
            resolve(result.join("\n"));
        }, 5000);
    });
};


// But notice that this approach affect to the function usage...
// (It returns a promise, not actual data):
myFunc("Hello!!").then(function(data){
    console.log(data);
}).catch(function(err){
    console.error(err);
});