javascript - Node.JS - 无法使用 try/catch block 获得异步抛出

Question

当我在 Node 中创建异步函数并使用 await 时，我让执行等待 Promise 解析(可以是解析或拒绝)，我所做的是将 await Promise 放入 try/catch block 中，并在 Promise 拒绝的情况下抛出错误。问题是，当我在 try/catch block 内调用此异步函数来捕获错误时，我会收到 UnhandledPromiseRejectionWarning。但是使用 await 的全部意义不是等待 promise 解决并返回其结果吗？看起来我的异步函数正在返回一个 promise 。

示例 - 代码UnhandledPromiseRejectionWarning:

let test = async () => {
   let promise = new Promise((resolve, reject) => {
      if(true) reject("reject!");
      else resolve("resolve!");
   });
   try{
      let result = await promise;
   }
   catch(error) {
      console.log("promise error =", error);
      throw error;
   }
}

let main = () => {
   try {
      test();
   }
   catch(error){
      console.log("error in main() =", error);
   }
}

console.log("Starting test");
main();

Answer 1

异步函数总是返回promise。事实上，它们总是返回 native promise (即使您返回 bluebird 或常量)。 async/await 的目的是减少 .then 回调 hell 的版本。您的程序的主函数中仍然必须至少有一个 .catch 来处理到达顶部的任何错误。

这对于顺序异步调用来说非常好，例如；

async function a() { /* do some network call, return a promise */ }

async function b(aResult) { /* do some network call, return a promise */ }

async function c() {
   const firstRes = (await (a() /* promise */) /* not promise */);
   const secondRes = await b(firstRes/* still not a promise*/);
}

如果不在函数内部，则无法await某些内容。通常这意味着您的 main 函数或 init 或任何您所说的函数不是异步的。这意味着它不能调用 await 并且必须使用 .catch 来处理任何错误，否则它们将是未处理的拒绝。在 Node 版本中的某个时刻，这些将开始删除您的 Node 进程。

将 async 视为返回 native Promise - 无论如何 - 将 await 视为“同步”解包 Promise。

• 注意异步函数返回 native Promise，它不会同步解析或拒绝:

  Promise.resolve(2).then(r => console.log(r)); console.log(3); // 3 printed before 2
  Promise.reject(new Error('2)).catch(e => console.log(e.message)); console.log(3); // 3 before 2
  

• 异步函数返回同步错误作为被拒绝的 promise 。

  async function a() { throw new Error('test error'); }
  
  // the following are true if a is defined this way too
  async function a() { return Promise.reject(new Error('test error')); }
  
  /* won't work */ try { a() } catch(e) { /* will not run */ }
  
  /* will work */ try { await a() } catch (e) { /* will run */ }
  
  /* will work */ a().catch(e => /* will run */)
  
  /* won't _always_ work */ try { return a(); } catch(e) { /* will not usually run, depends on your promise unwrapping behavior */ }