sleep（）的JavaScript版本是什么？_Javascript_Sleep

sleep（）的JavaScript版本是什么？

javascript

sleep（）的JavaScript版本是什么？,javascript,sleep,Javascript,Sleep,有没有比下面的pausecomp函数（）更好的方法在JavaScript中设计sleep 函数pausecomp（毫秒） { 变量日期=新日期（）； var curDate=null； do{curDate=new Date（）；} while（curDate日期对于神的爱，请不要做一个忙碌的等待睡眠函数。code>setTimeout和setInterval完成所有需要的操作 var showHide=document.getElementById（'showHide'）；设置间隔（（）=

有没有比下面的

pausecomp

函数（）更好的方法在JavaScript中设计

sleep

函数pausecomp（毫秒）
{
变量日期=新日期（）；
var curDate=null；
do{curDate=new Date（）；}
while（curDate日期<毫秒）；
}

这不是一个复制品；我想要一个真正的睡眠在一个函数的中间，而不是在一段代码执行之前的延迟。

< P>对于神的爱，请不要做一个忙碌的等待睡眠函数。code>setTimeout和

setInterval

完成所有需要的操作

var showHide=document.getElementById（'showHide'）；
设置间隔（（）=>{
showHide.style.visibility=“初始”；
设置超时（（）=>{
showHide.style.visibility=“隐藏”
}, 1000);
;
}, 2000);   
你好！再见为了对$Destity的爱，请不要进行繁忙的等待睡眠功能setTimeout
和setInterval
完成所有需要的操作

var showHide=document.getElementById（'showHide'）；
设置间隔（（）=>{
showHide.style.visibility=“初始”；
设置超时（（）=>{
showHide.style.visibility=“隐藏”
}, 1000);
;
}, 2000);   
你好！再见在JavaScript中，你不能这样睡觉，或者更确切地说，你不应该这样。运行sleep或while循环将导致用户的浏览器挂起，直到循环完成
使用您引用的链接中指定的计时器
 在JavaScript中，你不能这样睡觉，或者更确切地说，你不应该这样。运行sleep或while循环将导致用户的浏览器挂起，直到循环完成
使用您引用的链接中指定的计时器
 在JavaScript中，我重写了每个函数，以便它能尽快结束。您希望浏览器重新控制，以便它可以对DOM进行更改
每当我想在函数的中间休眠时，我就重构为使用<代码> SETTIMEOUTE（）< <代码> > < /P>
编辑
任何语言中臭名昭著的睡眠或延迟功能都有很多争议。有些人会说，应该总是有一个信号或回调来启动给定的功能，另一些人会说，有时任意的延迟时间是有用的。我要说的是，在这个行业中，每个人都有自己的规则，一条规则永远不能支配任何事情
编写sleep函数非常简单，并且通过JavaScript承诺变得更加有用：
// sleep time expects milliseconds
function sleep (time) {
  return new Promise((resolve) => setTimeout(resolve, time));
}

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

在JavaScript中，我重写了每个函数，以便它能够尽快结束。您希望浏览器重新控制，以便它可以对DOM进行更改
每当我想在函数的中间休眠时，我就重构为使用<代码> SETTIMEOUTE（）< <代码> > < /P>
编辑
任何语言中臭名昭著的睡眠或延迟功能都有很多争议。有些人会说，应该总是有一个信号或回调来启动给定的功能，另一些人会说，有时任意的延迟时间是有用的。我要说的是，在这个行业中，每个人都有自己的规则，一条规则永远不能支配任何事情
编写sleep函数非常简单，并且通过JavaScript承诺变得更加有用：
// sleep time expects milliseconds
function sleep (time) {
  return new Promise((resolve) => setTimeout(resolve, time));
}

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

第一:
定义要执行的函数，如下所示：
function alertWorld(){
  alert("Hello World");
}

然后使用setTimeout方法计划其执行：
setTimeout(alertWorld,1000)

注意两件事

第二个参数是以毫秒为单位的时间
作为第一个参数，您必须只传递函数的名称（引用），不带括号
首先：
定义要执行的函数，如下所示：
function alertWorld(){
  alert("Hello World");
}

然后使用setTimeout方法计划其执行：
setTimeout(alertWorld,1000)

注意两件事

第二个参数是以毫秒为单位的时间
作为第一个参数，您必须只传递函数的名称（引用），不带括号
我同意其他海报的观点，忙碌的睡眠只是个坏主意
但是，setTimeout不会阻止执行，它会在设置超时后立即执行函数的下一行，而不是在超时过期后执行，因此无法完成与睡眠相同的任务
方法是将函数分解为前后两部分
function doStuff()
{
  //do some things
  setTimeout(continueExecution, 10000) //wait ten seconds before continuing
}

function continueExecution()
{
   //finish doing things after the pause
}

确保您的函数名仍然准确地描述了每一块正在执行的操作（即GatherInputHenWait和CheckInput，而不是funcPart1和funcPart2）
编辑
此方法实现了直到超时后才执行您决定的代码行的目的，同时仍然将控制权返回到客户端PC以执行它排队的任何其他内容
进一步编辑
正如评论中指出的，这绝对不会在循环中起作用。你可以做一些花哨的（丑陋的）黑客来让它在一个循环中工作，但总的来说，那只会导致灾难性的意大利面代码。
我同意其他海报，忙碌的睡眠只是个坏主意
但是，setTimeout不会阻止执行，它会在设置超时后立即执行函数的下一行，而不是在超时过期后执行，因此无法完成与睡眠相同的任务
方法是将函数分解为前后两部分
function doStuff()
{
  //do some things
  setTimeout(continueExecution, 10000) //wait ten seconds before continuing
}

function continueExecution()
{
   //finish doing things after the pause
}

确保您的函数名仍然准确地描述了每一块正在执行的操作（即GatherInputHenWait和CheckInput，而不是funcPart1和funcPart2）
编辑
此方法实现了直到超时后才执行您决定的代码行的目的，同时仍然将控制权返回到客户端PC以执行它排队的任何其他内容
进一步编辑
正如评论中指出的，这绝对不会在循环中起作用。您可以进行一些奇特（丑陋）的黑客攻击，使其在循环中工作，但一般来说，这只会导致灾难性的意大利面代码。如果您使用jQuery，实际上有人会
<html>
<body>
<div id="id1">DISPLAY</div>

<script>
//javascript sleep by "therealdealsince1982"; copyrighted 2009
//setTimeout
var i = 0;

function run() {
    //pieces of codes to run, can use switch statement
    if (i==0){document.getElementById("id1").innerHTML= "<p>code segment "+ i +" ran</p>"; sleep(1000);}
    if (i==1){document.getElementById("id1").innerHTML= "<p>code segment "+ i +" ran</p>"; sleep(2000);}
    if (i==2){document.getElementById("id1").innerHTML= "<p>code segment "+ i +" ran</p>"; sleep(3000);}
    if (i==3){document.getElementById("id1").innerHTML= "<p>code segment "+ i +" ran</p>";} //stops automatically
    i++;
}

function sleep(dur) {t=setTimeout("run()",dur);} //starts flow control again after dur

run(); //starts
</script>
</body>
</html>

<html>
<body>
<div id="id1">DISPLAY</div>

<script>
//javascript sleep by "therealdealsince1982"; copyrighted 2009
//setTimeout
var i = 0;

function flow() {
    run(i);
    i++; //code segment finished running, increment i; can put elsewhere
    sleep(1000);
    if (i==5) {clearTimeout(t);} //stops flow, must be after sleep()
}

function run(segment) {
    //pieces of codes to run, can use switch statement
    if (segment==0){document.getElementById("id1").innerHTML= "<p>code segment "+ segment +" is ran</p>"; }
    if (segment==1){document.getElementById("id1").innerHTML= "<p>code segment "+ segment +" is ran</p>"; }
    if (segment==2){document.getElementById("id1").innerHTML= "<p>code segment "+ segment +" is ran</p>"; }
    if (segment >2){document.getElementById("id1").innerHTML= "<p>code segment "+ segment +" is ran</p>"; }
}

function sleep(dur) {t=setTimeout("flow()",dur);} //starts flow control again after dur

flow(); //starts flow
</script>
</body>
</html>

<html>
<body>
<div id="id1">DISPLAY</div>

<script>
//javascript sleep by "therealdealsince1982"; copyrighted 2009
//setTimeout, switch
var i = 0;

function flow() {
    switch(i)
    {
        case 0:
            run(i);
            sleep(1000);
            break;
        case 1:
            run(i);
            sleep(2000);
            break;
        case 5:
            run(i);
            clearTimeout(t); //stops flow
            break;
        default:
            run(i);
            sleep(3000);
            break;
    }
}

function run(segment) {
    //pieces of codes to run, can use switch statement
    if (segment==0){document.getElementById("id1").innerHTML= "<p>code segment "+ segment +" is ran</p>"; }
    if (segment==1){document.getElementById("id1").innerHTML= "<p>code segment "+ segment +" is ran</p>"; }
    if (segment==2){document.getElementById("id1").innerHTML= "<p>code segment "+ segment +" is ran</p>"; }
    if (segment >2){document.getElementById("id1").innerHTML= "<p>code segment "+ segment +" is ran</p>"; }
    i++; //current segment of code finished running, next...
}

function sleep(dur) {t=setTimeout("flow()",dur);} //starts flow control again after dur

flow(); //starts flow control for first time...
</script>
</body>
</html>

function itemHandler(item)
{
    alert(item);
}

var itemSet = ['a','b','c'];

// Each call to itemHandler will execute
// 1 second apart
for(var i=0; i<itemSet.length; i++)
{
    var secondsUntilExecution = i;
    itemHandler.delay(secondsUntilExecution, item)
}

alert('start');
var a = 'foo';
//lots of code
setTimeout(function(){  //Beginning of code that should run AFTER the timeout
    alert(a);
    //lots more code
},5000);  // put the timeout here

try
{
  java.lang.Thread.sleep(timeInMilliseconds);
}
catch (e)
{
  /*
   * This will happen if the sleep is woken up - you might want to check
   * if enough time has passed and sleep again if not - depending on how
   * important the sleep time is to you.
   */
}

// Basic sleep function based on ms.
// DO NOT USE ON PUBLIC FACING WEBSITES.
function sleep(ms) {
    var unixtime_ms = new Date().getTime();
    while(new Date().getTime() < unixtime_ms + ms) {}
}

<html>
<head>

<script type="text/javascript">

  function load() {
    var appletRef = document.getElementById("app");
    window.java = appletRef.Packages.java;
  } // endfunction

</script>

<body onLoad="load()">

<embed id="app" code="java.applet.Applet" type="application/x-java-applet" MAYSCRIPT="true" width="0" height="0" />

java.lang.Thread.sleep(xxx)

var isReady = eval('document.batchForm.ready');
isReady.value=0;

frames['rpc_frame'].location.href=url;

while (isReady.value==0) {
  java.lang.Thread.sleep(250);
} // endwhile

window.frames['rpc_frame'].focus();
window.frames['rpc_frame'].print();

var Fiber = require('fibers');

function sleep(ms) {
    var fiber = Fiber.current;
    setTimeout(function() {
        fiber.run();
    }, ms);
    Fiber.yield();
}

Fiber(function() {
    console.log('wait... ' + new Date);
    sleep(1000);
    console.log('ok... ' + new Date);
}).run();
console.log('back in main');

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

function sleep(milliseconds) {
  var start = new Date().getTime();
  for (var i = 0; i < 1e7; i++) {
    if ((new Date().getTime() - start) > milliseconds){
      break;
    }
  }
}

// This is based on the latest ES6 drafts.
// js 1.7+ (SpiderMonkey/Firefox 2+) syntax is slightly different

// run code you want to sleep here (ommit star if using js 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(){
        // ommit .value if using js 1.7
        var nextSleep = generator.next().value;
        resume(nextSleep, generator);
    }, ms);
}

// initialize generator and get first sleep for recursive function
var
    generator = main(),
    firstSleep = generator.next().value;

// initialize recursive resume function
resume(firstSleep, generator);

function sleep(n){
  var request = new XMLHttpRequest();
  request.open('GET', '/sleep.php?n=' + n, false);  // `false` makes the request synchronous
  request.send(null);
}

<?php sleep($_GET['n']);

function after(ms, fn){ setTimeout(fn, ms); }
function every(ms, fn){ setInterval(fn, ms); }

after = (ms, fn)-> setTimeout fn, ms
every = (ms, fn)-> setInterval fn, ms

after(1000, function(){
    console.log("it's been a second");
    after(1000, function(){
        console.log("it's been another second");
    });
});

// sleep.js

var Fiber = require('fibers');

function sleep(ms) {
    var fiber = Fiber.current;
    setTimeout(function() {
        fiber.run();
    }, ms);
    Fiber.yield();
}

Fiber(function() {
    console.log('wait... ' + new Date);
    sleep(1000);
    console.log('ok... ' + new Date);
}).run();
console.log('back in main');

$ node sleep.js
wait... Fri Jan 21 2011 22:42:04 GMT+0900 (JST)
back in main
ok... Fri Jan 21 2011 22:42:05 GMT+0900 (JST)

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

sleep(2000).then(function() { 
   // Do something
});

function sleep(seconds){
    var waitUntil = new Date().getTime() + seconds*1000;
    while(new Date().getTime() < waitUntil) true;
}

sleep(2); // Sleeps for 2 seconds

const sleep = require('util').promisify(setTimeout)

async function main() {
    console.time("Slept for")
    await sleep(3000)
    console.timeEnd("Slept for")
}

main()

async function asyncGenerator() {
    while (goOn) {
      var fileList = await listFiles(nextPageToken);
      await sleep(3000)
      var parents = await requestParents(fileList);
    }
  }

await new Promise(resolve => setTimeout(resolve, 5000));