异步函数+ await + setTimeout的组合

我正在尝试使用新的异步特性，我希望解决我的问题能够在未来帮助到其他人。这是我正在工作的代码:

  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循环运行得太快，脚本每秒向谷歌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函数中返回，匿名函数中的回调等。

674261 次浏览
小开

setTimeout不是async函数，所以你不能在ES7 async-await中使用它。但是你可以使用ES6 承诺来实现你的sleep函数:

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

然后你就可以在ES7 async-await中使用这个新的sleep函数了:

var fileList = await sleep(listFiles, nextPageToken)

请注意，我只是回答你关于将ES7 async/await与setTimeout结合的问题，尽管它可能无助于解决你每秒发送太多请求的问题。

现代node.js版本有一个内置的异步超时实现，可以通过util.promisify helper访问:

const {promisify} = require('util');
const setTimeoutAsync = promisify(setTimeout);
小开
最佳答案

您的sleep函数不能工作，因为setTimeout没有(还没有?)返回一个可能是awaited的承诺。您将需要手动承诺:

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秒。

小开

Node 7.6以来，你可以结合utils模块中的promisify函数和setTimeout()函数。

node . js

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

Javascript

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

使用

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

快速的一行，内联方式

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

如果你想使用与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

小开

下面的代码可以在Chrome和Firefox以及其他浏览器中运行。

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

但是在ie浏览器中，我得到了"(resolve **=>** setTimeout..."的语法错误

小开

这是在一行程序中快速修复的方法。

希望这能有所帮助。

// WAIT FOR 200 MILISECONDS TO GET DATA //
await setTimeout(()=>{}, 200);
小开 
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
小开

从戴夫的回答中获得灵感，制作了一个util

基本上传递了一个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);
}
小开

这是我2020年在AWS labdas中使用nodejs的版本

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)
...
}
小开 
await setTimeout(()=>{}, 200);

如果您的Node版本是15及以上，将正常工作。

小开

Timers承诺API

await setTimeout终于在Node.js 16中出现了，不再需要使用util.promisify():

import { setTimeout } from 'timers/promises';


(async () => {
const result = await setTimeout(2000, 'resolved')
// Executed after 2 seconds
console.log(result); // "resolved"
})()

Node.js官方文档:Timers承诺API(库已经在Node中构建)

小开 
await new Promise(resolve => setTimeout(() => { resolve({ data: 'your return data'}) }, 1000))
小开

如何一次记录所有的响应?

async function sayHello(name) {
let greet = `Hey! ${name} very nice to meet you bud.`;
setTimeout(() => {
return {
greet,
createdAt: new Date(),
};
}, 1000);
}


const response1 = async () => await sayHello("sounish");
const response2 = async () => await sayHello("alex");
const response3 = async () => await sayHello("bill");


async function getData() {
const data1 = await sayHello("sounish");
const data2 = await sayHello("alex");
const data3 = await sayHello("bill");
return { data1, data2, data3 };
}


Promise.all([sayHello("sounish"), sayHello("alex"), sayHello("bill")]).then(
(allResponses) => {
console.log({ allResponses });
}
);


getData().then((allData) => {
console.log({ allData });
});
小开

我把这段代码片段留给那些想用setTimeout获取API调用(例如获取客户端)的人:

const { data } = await new Promise(resolve => setTimeout(resolve, 250)).then(() => getClientsService())
setName(data.name || '')
setEmail(data.email || '')
小开

我想指出一个强大的扩展Promise.all。对于一个承诺只有时间限制的情况，一个相当优雅的解决方案是让承诺与超时赛跑(例如new Promise((resolve) => setTimeout(resolve, timeout)))。

await new Promise.race([myPromise, timeoutPromise])

一旦一个承诺完成，就会继续。myPromise可以在内部等待不同的超时，或者简单地使用Promise.all

const timeout = ms => new Promise((resolve) => setTimeout(resolve, ms));
await Promise.race([
Promise.all([myPromise, timeout(500)]),
timeout(5000)
]);

结果是异步调用的运行频率不会超过每秒两次，在出现某些(网络/服务器?)错误时，超时时间为5秒。

此外，您可以使这个非常通用和可定制的函数如下:

function callWithTimeout(promise, msTimeout=5000, throws=false) {
const timeout = ms => new Promise((resolve, reject) =>
setTimeout(throws ? reject : resolve, ms));
await Promise.race([
//depends whether you want to wait there or just pass the promise itself
Promise.all([promise, timeout(500)]),
timeout(msTimeout)
]);
}

它最终允许您自定义超时时间以及承诺是否应该成功或在超时时抛出。拥有这样健壮的通用实现可以在将来为您省去很多麻烦。您还可以设置一个字符串而不是布尔值throws，并将此变量绑定到reject，用于自定义错误消息:reject.bind(undefined, throws)

注意，你不应该守口如瓶。

const myPromise = async x => x;
//will never time out and not because myPromise will finish immediatelly
callWithTimeout(await myPromise(), 200, true);
//will possibly timeout after 200 ms with an exception
callWithTimeout(myPromise(), 200, true);
小开

有了标志着答案，我有一个lint错误[no-promise- executoror -return]，所以我找到了在这里的更正版本，使用花括号，以便明确不返回任何东西的意图:

const timeout = (ms) =>
new Promise(resolve => {
setTimeout(resolve, ms)
})

提交答案