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

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 Promises API(库已经在Node中构建)

我想指出Promise.all的一个强大扩展。一个相当优雅的解决方案是让一个promise只有时间限制(例如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)
    ]);
}
    

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

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

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

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

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

从戴夫的回答中得到灵感，做了一个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);
}

从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")
})()