在异步函数的 finally 块中等待导致 PromiseRejectionHandledWarning

Question

我在我的 NodeJs 代码中使用了asyncawait，代码结构如下。

async function main(){
    try {
        await someFunctionThatReturnsRejectedPromise()
    } catch(e) {
        console.log(e)
    }
}

async function someFunctionThatReturnsRejectedPromise() {
    try {
        await new Promise((resolve,reject) => {
            setTimeout(() => {
                reject('something went wrong')
            }, 1000);
        })
    } catch(e) {
        return Promise.reject(e)
    } finally {
        await cleanup() // remove await here and everything is fine
    }
}


function cleanup() {
    return new Promise(resolve => {
        setTimeout(() => {
            resolve('cleaup successful')
        }, 1000);
    })
}

main();

在 finally 块中，我正在做一些async 清理工作，肯定会解决。 但是这段代码正在抛出PromiseRejectionHandledWarning

(node:5710) UnhandledPromiseRejectionWarning: something went wrong
(node:5710) UnhandledPromiseRejectionWarning: Unhandled promise rejection. This error originated either by throwing inside of an async function without a catch block, or by rejecting a promise which was not handled with .catch(). (rejection id: 1)
(node:5710) [DEP0018] DeprecationWarning: Unhandled promise rejections are deprecated. In the future, promise rejections that are not handled will terminate the Node.js process with a non-zero exit code.
something went wrong
(node:5710) PromiseRejectionHandledWarning: Promise rejection was handled asynchronously (rejection id: 1)

据我所知，我不会在这里留下任何未处理的承诺。 我究竟做错了什么？ finally 是否应该按设计同步阻止？如果是，为什么会这样？

更新 1：

如果我将someFunctionThatReturnsRejectedPromise 转换为良好的then 和catch，它可以正常工作：

function someFunctionThatReturnsRejectedPromise() {
    return (new Promise((resolve,reject) => {
        setTimeout(() => {
            reject('something went wrong')
        }, 1000);
    })).catch(e => {
        return Promise.reject(e)
    }).finally(() => {
        return cleanup()
    })
}

更新 2：（了解问题）

如果我await返回Promise，问题就解决了。

 return await Promise.reject(e)

这让我明白我做错了什么。 我打破了await 链（部分同义于在then/catch 语法中不返回Promise）。 谢谢大家:)

Answer 1

当 Promise 拒绝时，必须在当前调用堆栈清除之前处理，否则将出现未处理的拒绝。你有：

} catch (e) {
  return Promise.reject(e)
} finally {
  await cleanup() // remove await here and everything is fine
}

如果您删除 await，someFunctionThatReturnsRejectedPromise 将返回 立即在被拒绝的 Promise 被构造之后，所以被拒绝的 Promise Promise.reject(e) 被main 中的catch 捕获。但是如果有任何延迟，被拒绝的 Promise 将不会立即处理；你的await cleanup()将意味着被拒绝的Promise在someFunctionThatReturnsRejectedPromise返回之前有一段时间没有被处理，这意味着main的catch无法及时处理被拒绝的Promise。

您可以使用的另一种方法是将错误包装在Error 而不是Promise.reject 中，然后检查结果是否是main 中的instanceof Error：

window.addEventListener('unhandledrejection', () => console.log('unhandled rejection!'));

async function main() {
  const result = await someFunctionThatReturnsRejectedPromise();
  if (result instanceof Error) {
    console.log('Error "caught" in main:', result.message);
  }
}

async function someFunctionThatReturnsRejectedPromise() {
  try {
    await new Promise((resolve, reject) => {
      setTimeout(() => {
        reject('something went wrong')
      }, 1000);
    })
  } catch (e) {
    return new Error(e);
  } finally {
    await cleanup()
  }
}


function cleanup() {
  return new Promise(resolve => {
    setTimeout(() => {
      resolve('cleaup successful')
    });
  })
}

main();

Answer 2

更新答案替换

Promise.reject(e) 与 throw e;

所以函数变成了

async function someFunctionThatReturnsRejectedPromise() {
   try {
       await new Promise((resolve,reject) => {
           setTimeout(() => {
               reject('something went wrong')
           }, 1000);
       })
   } catch(e) {
       throw e;
   } finally {
       await cleanup() // remove await here and everything is fine
   }
}

原因

someFunctionThatReturnsRejectedPromise 方法首先拒绝Promise。所以控制流转到方法main catch 块。 后来cleanup 方法尝试做同样的事情。也就是拒绝已经拒绝的承诺。因此你得到错误

Promise.reject 与throw 子句有点不同。请参考throw vs Promise.reject

这就是为什么从 cleanup() 中删除 await 或从 cleanup 中删除 return 方法有效的原因。因为这会将Promise 从当前控制流中分离出来。