无法从异步promise执行器函数中引发错误

Question

我一直试图从概念上理解为什么下面的代码没有抓住抛出的代码。如果您从new Promise（async（解决，...部分删除async关键字，那么它工作正常，所以它与Promise执行器是一个异步函数的事实有关。

(async function() {

  try {
    await fn();
  } catch(e) {
    console.log("CAUGHT fn error -->",e)
  }

})();

function fn() {

  return new Promise(async (resolve, reject) => {
    // ...
    throw new Error("<<fn error>>");
    // ...
  });

}

这里、这里和这里的答案都重复了“如果你在任何其他异步回调中，你必须使用拒绝”，但是“异步”并不是指异步函数，所以我认为他们的解释不适用于这里（如果他们这样做，我不明白怎么做）。

如果我们使用拒绝代码而不是抛出代码，上面的代码可以正常工作。我想从根本上理解，为什么扔在这里不起作用。谢谢！

Answer 1

因为从promise执行者内部与外部世界“沟通”的唯一方式是使用resolve和reject功能。您可以使用以下示例：

function fn() {
  return new Promise(async (resolve, reject) => {
    // there is no real reason to use an async executor here since there is nothing async happening
    try {
      throw new Error('<<fn error>>')
    } catch(error) {
      return reject(error);
    }
  });
}

例如，当您想要执行一些具有方便的异步函数但又需要回调的操作时。下面的人为示例通过使用asyncfs.promises.readFile函数和基于回调的fs.writeFile函数读取文件来复制文件。在现实世界中，您永远不会像这样混合使用fs函数，因为没有必要这样做。但是有些库，如stylus和pug，使用回调，我在这些场景中一直使用类似的东西。

const fs = require('fs');

function copyFile(infilePath, outfilePath) {
  return new Promise(async (resolve, reject) => {
    try {
      // the fs.promises library provides convenient async functions
      const data = await fs.promises.readFile(infilePath);
      // the fs library also provides methods that use callbacks
      // the following line doesn't need a return statement, because there is nothing to return the value to
      // but IMO it is useful to signal intent that the function has completed (especially in more complex functions)
      return fs.writeFile(outfilePath, data, (error) => {
        // note that if there is an error we call the reject function
        // so whether an error is thrown in the promise executor, or the callback the reject function will be called
        // so from the outside, copyFile appears to be a perfectly normal async function
        return (error) ? reject(error) : resolve();
      });
    } catch(error) {
      // this will only catch errors from the main body of the promise executor (ie. the fs.promises.readFile statement
      // it will not catch any errors from the callback to the fs.writeFile statement
      return reject(error);
      // the return statement is not necessary, but IMO communicates the intent that the function is completed
    }
  }
}

显然，每个人都说这是一个反模式，但当我想在做一些只能通过回调来完成的事情之前做一些异步的事情时，我总是使用它（而不是像我设计的例子那样复制文件）。我不明白为什么人们认为这是一种反模式（使用异步promise执行器），并且还没有看到一个例子让我相信它应该被接受为一般规则。

Answer 2

这是Promise构造函数反模式的异步/等待版本！

切勿将异步函数用作promise执行器函数_{（即使您可以使其工作¹）}！

_{[1：通过调用解决和拒绝而不是使用返回和抛出语句]}

他们所说的“异步”并不是指async函数，所以我认为他们的解释在这里不适用

他们也可以。它无法工作的一个简单例子是

new Promise(async function() {
    await delay(…);
    throw new Error(…);
})

这相当于

new Promise(function() {
    return delay(…).then(function() {
        throw new Error(…);
    });
})

现在可以清楚地看到，抛出的代码在异步回调中。

Promise构造函数只能捕获同步异常，而async函数从不抛出-它总是返回一个Promise（可能会被拒绝）。并且该返回值被忽略，因为promise正在等待调用resolve。