什么是未处理的promise拒绝？

Question

为了学习角度2，我正在尝试他们的教程。

我得到这样的错误：

(node:4796) UnhandledPromiseRejectionWarning: Unhandled promise rejection (r                                                                                                     ejection id: 1): Error: spawn cmd ENOENT
[1] (node:4796) 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.

我在SO中浏览了不同的问题和答案，但没有发现什么是“未处理的promise拒绝”。

有人能简单地解释一下它是什么，以及＜code＞错误：生成cmd ENOENT＜/code＞是什么，当它出现时，我需要检查什么才能消除这个警告吗？

Answer 1

promise被拒绝后可以“处理”。也就是说，可以在提供catch处理程序之前调用promise的reject回调。这种行为对我来说有点麻烦，因为一个人可以写。。。

var promise = new Promise(function(resolve) {
kjjdjf(); // this function does not exist });

…在这种情况下，Promise被静默拒绝。如果忘记添加捕捉处理程序，代码将继续静默运行而没有错误。这可能会导致挥之不去且难以找到的错误。

在Node.js的情况下，有人谈论处理这些未处理的Promise拒绝并报告问题。这让我想到了ES7 async/wait。考虑这个例子：

async function getReadyForBed() {
  let teethPromise = brushTeeth();
  let tempPromise = getRoomTemperature();

  // Change clothes based on room temperature
  let temp = await tempPromise;
  // Assume `changeClothes` also returns a Promise
  if(temp > 20) {
    await changeClothes("warm");
  } else {
    await changeClothes("cold");
  }

  await teethPromise;
}

在上面的例子中，假设在满足getRoomTemperature之前，toothPromise被拒绝（错误：牙膏用完了！）。在这种情况下，将有一个未处理的 Promise 拒绝，直到等待 toothPromise。

我的观点是……如果我们认为未处理的Promise拒绝是一个问题，那么稍后由等待处理的Promes可能会被无意中报告为错误。同样，如果我们认为未处理的Promise拒绝没有问题，那么合法的错误可能不会被报告。

对此有何看法？

这与Node.js项目中的讨论有关：

默认未处理的拒绝检测行为

如果你这样写代码：

function getReadyForBed() {
  let teethPromise = brushTeeth();
  let tempPromise = getRoomTemperature();

  // Change clothes based on room temperature
  return Promise.resolve(tempPromise)
    .then(temp => {
      // Assume `changeClothes` also returns a Promise
      if (temp > 20) {
        return Promise.resolve(changeClothes("warm"));
      } else {
        return Promise.resolve(changeClothes("cold"));
      }
    })
    .then(teethPromise)
    .then(Promise.resolve()); // since the async function returns nothing, ensure it's a resolved promise for `undefined`, unless it's previously rejected
}

当getReadyForBed被调用时，它将同步创建最终的(未返回的)promise——这将具有与任何其他promise相同的“未处理的拒绝”错误(当然，根据引擎的不同，可能什么也没有)。(我发现你的函数不返回任何东西很奇怪，这意味着你的异步函数产生了一个未定义的promise。

如果我现在做了一个Promise而没有catch，并且稍后添加了一个，那么大多数“未处理的拒绝错误”实现实际上会在我稍后处理它时收回警告。换句话说，async/await不会以我所看到的任何方式改变“未处理的拒绝”讨论。

为了避免这个陷阱，请按如下方式编写代码:

async function getReadyForBed() {
  let teethPromise = brushTeeth();
  let tempPromise = getRoomTemperature();

  // Change clothes based on room temperature
  var clothesPromise = tempPromise.then(function(temp) {
    // Assume `changeClothes` also returns a Promise
    if(temp > 20) {
      return changeClothes("warm");
    } else {
      return changeClothes("cold");
    }
  });
  /* Note that clothesPromise resolves to the result of `changeClothes`
     due to Promise "chaining" magic. */

  // Combine promises and await them both
  await Promise.all(teethPromise, clothesPromise);
}

请注意，这应该可以防止任何未处理的promise拒绝。

Answer 2

这是用＜code＞完成＜code＞Promise＜/code＞的时候。reject（）或在异步执行的代码中抛出异常，而没有。catch（）确实处理了拒绝。

被拒绝的promise就像一个向应用程序入口点冒泡的异常，并导致根错误处理程序产生输出。

请参见

• https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Promise/reject
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/catch

Answer 3

此错误的起源在于每个promise都需要处理promise拒绝，即有一个. catt（…）。您可以通过在下面给出的代码中向promise添加. catt（…）来避免同样的情况。

例如，函数Ptest（）将根据全局变量Somevar的值解析或拒绝promise

var somevar = false;
var PTest = function () {
    return new Promise(function (resolve, reject) {
        if (somevar === true)
            resolve();
        else
            reject();
    });
}
var myfunc = PTest();
myfunc.then(function () {
     console.log("Promise Resolved");
}).catch(function () {
     console.log("Promise Rejected");
});

在某些情况下，即使我们已经为promise编写了. get（…），也会出现“未处理的promise拒绝”消息。这完全取决于您如何编写代码。即使我们正在处理get，以下代码也会生成“未处理的promise拒绝”。

var somevar = false;
var PTest = function () {
    return new Promise(function (resolve, reject) {
        if (somevar === true)
            resolve();
        else
            reject();
    });
}
var myfunc = PTest();
myfunc.then(function () {
     console.log("Promise Resolved");
});
// See the Difference here
myfunc.catch(function () {
     console.log("Promise Rejected");
});

不同之处在于您不将. get（…）作为链处理，而是作为单独的。出于某种原因，JavaScript引擎将其视为没有未处理的promise拒绝的promise。