使用异步函数+await+setTimeout的组合

使用marked答案后，我遇到了一个lint错误[no-promise-executor-return]，所以我在这里找到了已经修正的版本，使用花括号明确表达不返回任何内容的意图：

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

await setTimeout(()=>{}, 200);

如果你的Node版本是15或以上，它将可以正常工作。

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)

请注意，不应使用await传递承诺：

const myPromise = async x => x;
//will never time out and not because myPromise will finish immediatelly
callWithTimeout(await myPromise(), 2000, true); 
//will possibly timeout after 2 sec with an exception, or finish 
callWithTimeout(myPromise(), 2000, true); 

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

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..."

如何一次性记录所有响应？

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

我想解决一个我认为相关的问题：每30秒自动刷新页面的能力，但同时每秒更新屏幕上的一些计时器，并确保这两个功能不冲突。我的谷歌搜索引导我来到了你在这里提出的问题，所以我想分享一下我想出来的东西，以帮助其他人：

class Elapsed
{
    constructor()
    {
        this.start = performance.now()
    }
    elapsed_seconds( seconds )
    {
        let elapsed_seconds = ( performance.now() - this.start ) * 0.001
        return elapsed_seconds >= seconds
    }
}

async function sleep( seconds )
{
    let promise = new Promise(( resolve, _ ) => {
        setTimeout( () => resolve(), seconds * 1000 )
    })
    await promise
}

async function refresh()
{
    // do something
    return new Elapsed()
}

async function auto_refresh()
{
    while( true )
    {
        let last_refresh = await refresh()
        while( !last_refresh.elapsed_seconds( 30 ))
        {
            await update_counters()
            await sleep( 1 )
        }
    }
}

setTimeout(async () => {
   var x = await asyncFunction(); 
}, 5000)

这是一个更快的一行代码修复。

希望这能有所帮助。

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