异步功能+等待+ setTimeout的组合


305

我正在尝试使用新的异步功能,希望解决我的问题以后能对其他人有所帮助。这是我的代码正在工作:

  async function asyncGenerator() {
    // other code
    while (goOn) {
      // other code
      var fileList = await listFiles(nextPageToken);
      var parents = await requestParents(fileList);
      // other code
    }
    // other code
  }

  function listFiles(token) {
    return gapi.client.drive.files.list({
      'maxResults': sizeResults,
      'pageToken': token,
      'q': query
    });
  }

问题是我的while循环运行得太快,脚本每秒向Google API发送太多请求。因此,我想构建一个睡眠函数以延迟请求。因此,我也可以使用此功能来延迟其他请求。如果还有其他方法可以延迟请求,请告诉我。

无论如何,这是我的新代码不起作用。请求的响应在setTimeout中返回给匿名异步函数,但是我只是不知道如何将响应返回给睡眠函数resp。到初始asyncGenerator函数。

  async function asyncGenerator() {
    // other code
    while (goOn) {
      // other code
      var fileList = await sleep(listFiles, nextPageToken);
      var parents = await requestParents(fileList);
      // other code
    }
    // other code
  }

  function listFiles(token) {
    return gapi.client.drive.files.list({
      'maxResults': sizeResults,
      'pageToken': token,
      'q': query
    });
  }

  async function sleep(fn, par) {
    return await setTimeout(async function() {
      await fn(par);
    }, 3000, fn, par);
  }

我已经尝试了一些选项:将响应存储在全局变量中,然后从sleep函数返回它,在匿名函数中回调,等等。

Answers:


613

您的sleep函数不起作用,因为setTimeout还没有(返回?)返回可能被await编辑的promise 。您将需要手动启用它:

function timeout(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
}
async function sleep(fn, ...args) {
    await timeout(3000);
    return fn(...args);
}

顺便说一句,为了减慢循环速度,您可能不想使用sleep接受回调并像这样延迟它的函数。我宁愿建议做类似的事情

while (goOn) {
  // other code
  var [parents] = await Promise.all([
      listFiles(nextPageToken).then(requestParents),
      timeout(5000)
  ]);
  // other code
}

因此计算parents至少需要5秒钟。


11
喜欢这种Promise.all方法。如此简单而优雅!
安舒尔·古卡(Anshul Koka),

4
表示的含义是什么var [parents]?我以前没看过,这对Google来说是一件困难的事
natedog

6
@NateUsher这是数组的破坏
Bergi

1
@tinkerr 如果需要等待超时,则需要将其声明为异步 -不。一个函数只需要返回一个可以等待的承诺(或者实际上,一个thenable就足够了)。它是如何实现的取决于功能的实现,而不必是async function
Bergi

2
@naisanza没有,async/ await基于承诺。它替换的唯一东西是then调用。
Bergi

150

从Node 7.6开始,您可以将promisifyutils模块中的functions 函数与结合使用setTimeout()

Node.js

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

Java脚本

const sleep = m => new Promise(r => setTimeout(r, m))

用法

(async () => {
    console.time("Slept for")
    await sleep(3000)
    console.timeEnd("Slept for")
})()

1
在nodeJS await require('util').promisify(setTimeout)(3000)中也可以通过以下方式实现:await setTimeout[Object.getOwnPropertySymbols(setTimeout)[0]](3000)
Shl,

5
有趣的@Shl。我认为它比我的解决方案可读性差。如果人们不同意我可以将其添加到解决方案中?
哈利

2
需求版本显然比getOwnPropertySymbols版本好得多……如果它没有损坏……!
马特·弗莱彻

2
嘿,@哈利。看来您在自己的答案中包含了FlavorScape答案中的一个衬里。我不想假定你的意图,但这对他们来说并不公平。您可以回滚您的编辑吗?现在,它看起来有点像抄袭。
FélixGagnon-Grenier

2
我删除了单行代码,因为答案就在下面,但是我看到许多受欢迎的答案都会更新他们的答案,以包括其他新答案,因为大多数读者都不会不理会前几个答案。
哈里

129

快速的单线内联方式

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

3
let sleep = ms => new Promise( r => setTimeout(r, ms));//一个单一的班轮功能
Soldeplata Saketos,

8
甚至更短:-)await new Promise(resolve => setTimeout(resolve, 5000))
Liran Brimer '18

1
你们在同一行中使用“ resolve” x 2次是什么意思?如:等待新的Promise(resolve => setTimeout(resolve,1000)); 参考吗 本身还是什么?我会做这样的事情:function myFunc(){}; 等待新的Promise(resolve => setTimeout(myFunc,1000));
PabloDK

35

setTimeout不是async功能,因此您不能将其与ES7 async-await一起使用。但是您可以sleep使用ES6 Promise实现您的功能:

function sleep (fn, par) {
  return new Promise((resolve) => {
    // wait 3s before calling fn(par)
    setTimeout(() => resolve(fn(par)), 3000)
  })
}

然后,您可以在sleepES7 async-await中使用此新功能:

var fileList = await sleep(listFiles, nextPageToken)

请注意,我只是在回答有关将ES7 async / await与结合使用的问题setTimeout,尽管这可能无法解决每秒发送过多请求的问题。


更新:现代的node.js版本具有内置的异步超时实现,可通过util.promisify帮助器进行访问:

const {promisify} = require('util');
const setTimeoutAsync = promisify(setTimeout);

2
您不应该这样做,因为在fn抛出错误时不会被抓住。
Bergi 2015年

@Bergi我认为它new Promise在可能的范围内冒出sleep.catch
Florian Wendelborn

3
@Dodekeract不,它在异步setTimeout回调中,new Promise回调已经完成了很长时间。它会冒泡到全局环境,并作为未处理的异常抛出。
贝吉

>每秒发送太多请求的问题。您可能想使用“去抖动”来防止诸如UI触发过多请求的事情。
FlavorScape

5

如果您想使用相同的语法,setTimeout可以编写如下的帮助函数:

const setAsyncTimeout = (cb, timeout = 0) => new Promise(resolve => {
    setTimeout(() => {
        cb();
        resolve();
    }, timeout);
});

然后可以这样称呼它:

const doStuffAsync = async () => {
    await setAsyncTimeout(() => {
        // Do stuff
    }, 1000);

    await setAsyncTimeout(() => {
        // Do more stuff
    }, 500);

    await setAsyncTimeout(() => {
        // Do even more stuff
    }, 2000);
};

doStuffAsync();

我提出了要点:https : //gist.github.com/DaveBitter/f44889a2a52ad16b6a5129c39444bb57


1
delayRun这样的函数名在这里更有意义,因为它将延迟回调函数的运行X秒。国际海事组织不是一个非常令人期待的例子。
mix3d

2
var testAwait = function () {
    var promise = new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve('Inside test await');
        }, 1000);
    });
    return promise;
}

var asyncFunction = async function() {
    await testAwait().then((data) => {
        console.log(data);
    })
    return 'hello asyncFunction';
}

asyncFunction().then((data) => {
    console.log(data);
});

//Inside test await
//hello asyncFunction

0

以下代码可在Chrome,Firefox和其他浏览器中使用。

function timeout(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
}
async function sleep(fn, ...args) {
    await timeout(3000);
    return fn(...args);
}

但是在Internet Explorer中,我收到了一个语法错误 "(resolve **=>** setTimeout..."


0

Dave答案中获得灵感的工具

基本上在done操作完成时传入回调以进行调用。

// Function to timeout if a request is taking too long
const setAsyncTimeout = (cb, timeout = 0) => new Promise((resolve, reject) => {
  cb(resolve);
  setTimeout(() => reject('Request is taking too long to response'), timeout);
});

这是我的用法:

try {
  await setAsyncTimeout(async done => {
    const requestOne = await someService.post(configs);
    const requestTwo = await someService.get(configs);
    const requestThree = await someService.post(configs);
    done();
  }, 5000); // 5 seconds max for this set of operations
}
catch (err) {
  console.error('[Timeout] Unable to complete the operation.', err);
}

0

这是我在2020年在AWS Labdas中使用Node.js的版本

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

async function f1 (some){
...
}

async function f2 (thing){
...
}

module.exports.someFunction = async event => {
    ...
    await f1(some)
    await sleep(5000)
    await f2(thing)
    ...
}

-3

这是一种更快的单线修复。

希望这会有所帮助。

// WAIT FOR 200 MILISECONDS TO GET DATA //
await setTimeout(()=>{}, 200);

1
不起作用 这:await setTimeout(()=>{console.log('first')}, 200); console.log ('second')打印第二第一
gregn3

1
@ gregn3是重点。这是一种非阻塞解决方案,其中函数外部的代码可以在主程序流之外完成“阻塞操作”的同时继续执行。尽管您和Rommy和Mohamad提供的语法严格不正确,原因是需要在异步函数中调用await(可能是最近添加的),但我也在使用node.js。这是我调整过的解决方案。var test = async () => { await setTimeout(()=>{console.log('first')}, 1000); console.log ('second') }我延长了超时时间以显示它的用处。
扎里亚
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.