JavaScript中的睡眠-操作之间的延迟_Javascript_Sleep

JavaScript中的睡眠-操作之间的延迟

javascript

JavaScript中的睡眠-操作之间的延迟,javascript,sleep,Javascript,Sleep,在JavaScript执行另一个操作之前，有没有一种方法可以让我在JavaScript中进行睡眠例如： var a = 1+3; // Sleep 3 seconds before the next action here var b = a + 4; 您可以使用setTimeout实现类似效果： var a = 1 + 3; var b; setTimeout(function() { b = a + 4; }, (3 * 1000)); 这并不是真正的“睡眠”JavaSc

在JavaScript执行另一个操作之前，有没有一种方法可以让我在JavaScript中进行睡眠

例如：

 var a = 1+3;
 // Sleep 3 seconds before the next action here
 var b = a + 4;

您可以使用

setTimeout

实现类似效果：

var a = 1 + 3;
var b;
setTimeout(function() {
    b = a + 4;
}, (3 * 1000));

这并不是真正的“睡眠”JavaScript，它只是在一定的持续时间（以毫秒为单位指定）后执行传递给

setTimeout

的函数。虽然可以为JavaScript编写睡眠函数，但如果可能，最好使用

setTimeout

，因为它不会在睡眠期间冻结所有内容。

以防您确实需要

sleep（）

来测试某些内容。但是请注意，在调试时，大多数情况下它都会使浏览器崩溃——这可能就是您需要它的原因。在生产模式下，我将注释掉这个函数

function pauseBrowser(millis) {
    var date = Date.now();
    var curDate = null;
    do {
        curDate = Date.now();
    } while (curDate-date < millis);
}

函数pauseBrowser（毫秒）{
var date=date.now（）；
var curDate=null；
做{
curDate=Date.now（）；
}while（curDate日期<毫秒）；
}

不要在循环中使用

new Date（）

，除非您想浪费内存、处理能力、电池，甚至可能浪费设备的使用寿命。

ECMAScript 6版本，使用产量高的生成器进行“代码阻塞”：

因为最初的问题是在七年前发布的，所以我没有用确切的代码来回答，因为它太简单了，而且已经回答了。这将有助于解决更复杂的问题，例如，如果您至少需要两次睡眠，或者如果您计划对异步执行进行排序。请随意修改以满足您的需要

让睡眠时间=100
函数*时钟（）
{
设i=0
而
{
clk.next（）
}
，睡觉时间
)
产量
}
}
设clk=时钟（）
clk.next（）

如果您想要比

setTimeout

和

setInterval

更简单的函数，您可以将它们包装在只颠倒参数顺序的函数中，并给它们起个好名字：

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

现在它可以很容易地理解为“N毫秒后，…”（或“每N毫秒，…”）

2018更新最新的Safari、Firefox和Node.js现在也支持async/await/Promissions

使用异步/等待/承诺：（自2017年1月起，Chrome支持，但Safari、Internet Explorer、Firefox、Node.js不支持）

“严格使用”；
功能睡眠（ms）{
返回新承诺（res=>setTimeout（res，ms））；
}
设myAsyncFunc=async函数（）{
console.log（'Sleeping'）；
等待睡眠（3000）；
console.log（'Done'）；
}
myAsyncFunc（）有几种方法可以解决这个问题。如果我们使用setTimeout函数，让我们先了解它。
有三个参数：函数
或代码
，延迟
（毫秒）和参数。
由于函数或代码参数是必需的，因此其他参数是可选的。
一旦您没有输入延迟，它将被设置为零
有关setTimeout（）
的更多详细信息
简化版：
var a = 1 + 3;
var b;
console.log('a = ' + a);
setTimeout(function(){ 
    b = a + 4; 
    console.log('b = ' + b);
}, 1000);

输出：

a=4

24-->活动超时列表的编号标识符

b=8



使用参数pass：
var a = 1 + 3;
var b;
console.log('a = ' + a);
setTimeout(myFunction, 1000, a);

function myFunction(a)
{
    var b = a + 4;
    console.log('b = ' + b);
}

输出：

a=4

25-->活动超时列表的编号标识符

b=8




浏览器支持：
Chrome     Firefox     Edge     Safari     Opera
1.0        1.0         4.0      1.0        4.0
Chrome Firefox Edge Safari Opera浏览器
1.0        1.0         4.0      1.0        4.0
这是我的模型，它展示了如何使用生成器函数（ES6）在javascript中“sleep”或“DoEvents”。注释代码：
<html>
<head>
<script>
  "use strict"; // always
  // Based on post by www-0av-Com https://stackoverflow.com/questions/3143928
  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function*
  var divelt, time0, globaln = 0; // global variables
  var MainGenObj = Main(); // generator object = generator function()
window.onload = function() {
  divelt = document.getElementsByTagName("body")[0]; // for addline()
  addline("typeof Main: " + typeof Main);
  addline("typeof MainDriver: " + typeof MainDriver);
  addline("typeof MainGenObj: " + typeof MainGenObj);
  time0 = new Date().valueOf(); // starting time ms
  MainDriver(); // do all parts of Main()
}
function* Main() { // this is "Main" -- generator function -- code goes here
  // could be loops, or inline, like this:

  addline("Part A, time: " + time() + ", " + ++globaln); // part A
  yield 2000;                    // yield for 2000 ms (like sleep)

  addline("Part B, time: " + time() + ", " +  ++globaln); // part B
  yield 3000;                    // yield for 3000 ms (or like DoEvents)

  addline("Part Z, time: " + time() + ", " +  ++globaln); // part Z (last part)
  addline("End, time: " + time());
}
function MainDriver() { // this does all parts, with delays
  var obj = MainGenObj.next(); // executes the next (or first) part of Main()
  if (obj.done == false) { // if "yield"ed, this will be false
    setTimeout(MainDriver, obj.value); // repeat after delay
  }
}
function time() { // seconds from time0 to 3 decimal places
  var ret = ((new Date().valueOf() - time0)/1000).toString();
  if (ret.indexOf(".") == -1) ret += ".000";
  while (ret.indexOf(".") >= ret.length-3) ret += "0";
  return ret;
}
function addline(what) { // output
  divelt.innerHTML += "<br />\n" + what;
}
</script>
</head>
<body>
<button onclick="alert('I\'m alive!');"> Hit me to see if I'm alive </button>
</body>
</html>


“严格使用”；//总是
//基于www-0av-Com发布的帖子https://stackoverflow.com/questions/3143928
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function*
var divelt，time0，globaln=0；//全局变量
var MainGenObj=Main（）；//生成器对象=生成器函数（）
window.onload=函数（）{
divelt=document.getElementsByTagName（“body”）[0]；//用于addline（）
addline（“主管道类型：+主管道类型”）；
addline（“主驱动程序类型：+主驱动程序类型”）；
addline（“MainGenObj类型：“+MainGenObj类型”）；
time0=新日期（）.valueOf（）；//开始时间毫秒
MainDriver（）；//执行Main（）的所有部分
}
function*Main（）{//这是“Main”--生成器函数--代码在这里
//可以是循环或内联，如下所示：
addline（“A部分，时间：“+time（）+”，“+++globaln”）；//A部分
产量2000；//2000毫秒的产量（如睡眠）
addline（“B部分，时间：“+time（）+”，“+++globaln”）；//B部分
产量3000；//3000毫秒的产量（或类似事件）
addline（“第Z部分，时间：“+time（）+”，“+++globaln）；//第Z部分（最后一部分）
addline（“结束，时间：+time（））；
}
函数MainDriver（）{//此函数执行所有部分，但有延迟
var obj=MainGenObj.next（）；//执行Main（）的下一部分（或第一部分）
如果（obj.done==false）{//如果“yield”为ed，则为false
setTimeout（MainDriver，obj.value）；//延迟后重复
}
}
函数time（）{//time0到小数点后3位之间的秒数
var ret=（（新日期（）.valueOf（）-time0）/1000）.toString（）；
如果（ret.indexOf（“.”==-1）ret+=.000”；
而（ret.indexOf（“.”>=ret.length-3）ret+=0；
返回ret；
}
函数addline（what）{//输出
divelt.innerHTML+=“
\n”+什么；
}
打我看看我是否还活着
另一种方法是使用Promise和setTimeout（注意，您需要在函数内部，并使用async关键字将其设置为asynchronous）：
尝试此功能：
const delay = (ms, cb) => setTimeout(cb, ms)

以下是您如何使用它：
console.log("Waiting for 5 seconds.")
delay(5000, function() {
  console.log("Finished waiting for 5 seconds.")
})

或者走承诺式：
const delay=ms=>新承诺（解析=>{
设置超时（解析，毫秒）
})

这里有一个。
这里有一个非常简单的方法，它“感觉”像一个同步睡眠/暂停，但却是合法的js异步代码

//创建一个简单的暂停函数
常数暂停=（tim）
console.log("Waiting for 5 seconds.")
delay(5000, function() {
  console.log("Finished waiting for 5 seconds.")
})

setTimeout(()=> { your_function(); }, 5000);

function sleep(ms) {
    return new Promise(resolve => setTimeout(() => resolve(), ms))
}

console.log("Synchronous call 1");
sleep(4000)
.then(() => console.log("Asynchronous call 1"));
sleep(2000)
.then(() => console.log("Asynchronous call 2"));
console.log("Synchronous call 2");
sleep(3000)
.then(() => console.log("Asynchronous call 3"));
console.log("Synchronous call 3");
sleep(5000)
.then(() => console.log("Asynchronous call 4"))
.then(sleep(7000)
.then(()=>console.log("Asynchronous call 5")))
console.log("Synchronous call 4");
setTimeout(() => {console.log("Asynchronous call 6")}, 8000);
console.log("Synchronous call 5");