节点8.6 javascriptpromise：UnHandledPromiseRejtionWarning

Question

我有一个错误：（节点： 6186）UnhandledPromiseRejtionWarning： UnHandledPromiseRejtionWarning： UnHandledPromiseRejtionWarning： UnHandledPromiseRejtionWarning（拒绝id： 1）： triep（节点： 6186）[DEP0018]DeprecationWarning：未处理的promise拒绝被弃用。将来，未处理的promise拒绝将终止Node.js进程，退出代码为非零. -------- ========= 两个CaughtCachError三个（节点： 6186）promise拒绝处理警告：promise拒绝被异步处理（拒绝id： 1）我正在按照嵌套顺序使用我的3个promise函数。p1，p2，p3-是我的promise函数，如下所示。我尝试在所有p1，p2，p3函数中添加promise拒绝，但它仍然相同

enter code here
var p1 = new Promise(function (resolve, reject) {
    setTimeout(function () {
       // resolve('ones')
                resolve('ones')
    }, 9000)
})
var p2 = new Promise(function (resolve, reject) {
    setTimeout(function () {
        // throw new Error('eeeee');
        //reject('two')
    resolve('two')
    }, 1000)
})
var p3 = new Promise(function (resolve, reject) {
    setTimeout(function () {
        reject('three')
    }, 4000)
})

p1.then(function(result){
    console.log("--------", result)
        // return p2.then(function(res){console.log(res)}).catch(function(err){console.log(err)})
        return p2
}).then(function(p2result){
    console.log("=========", p2result)
    return p3;
}).then(function(p3result){
    console.log('*********', p3result)
}).catch(function(err){
    console.log("CaughtCathchError", err)
})

Answer 1

如果您想创建一个拒绝/拒绝的promise，它将被捕获在队列中，而不是堆栈中，那么您可以执行以下操作：

var p3 = new Promise(function (resolve, reject) {
    setTimeout(function () {
        reject('three')
    }, 400)
});
//do not warn for p3 rejection but if you use it later (p3.then) or
//  return it in a promise chain you will have to catch it again
p3.catch(ignore=>ignore);

Answer 2

节点。js promise实现希望被拒绝的promise与catch（…）链接 或然后（…，…） 同步，否则会出现PromisejectionHandledWarning。未经处理的拒绝promise可能导致将来的例外情况。

通常，拒绝应该被视为任何其他错误，因此它最好是error的实例，而不是普通字符串。然后可以这样处理：

class ExpectedRejection extends Error {}

var p3 = new Promise(function (resolve, reject) {
    setTimeout(function () {
        resolve(new ExpectedRejection('three'))
    }, 4000)
})

...
.then(function(p3result){
  if (p3result instanceof ExpectedRejection)
    throw p3result;

  console.log('*********', p3result)
}).catch(function(err){
    console.log("CaughtCathchError", err)
})

类是特定的，可能不需要；可以替换为错误无处不在，因为错误解决方案是不常见的。

这种解决方案不是很常见，因为如果同时创建promise，它们彼此不依赖，通常可以使用Promise来处理。全部：

Promise.all([p1, p2, p3])
.then(function(p1result, p2result, p3result){
    console.log('*********', p3result)
}).catch(function(err){
    console.log("CaughtCathchError", err)
});

请注意，由于p1、p2和p3是同时创建的延迟，因此在这两种情况下，都会在9秒（延迟的最大持续时间）后触发catch。

Answer 3

p3是一个独立的promise，没有。捕捉。因此，当p3被拒绝ed时，您会得到未处理的PromisejectionWarning。即使p3在具有适当的catch的Promise链中稍后被消费，p3本身也没有catch。

您可以使用返回promise的函数，而不是p3，并确保捕获对该函数的所有调用：

var p1 = new Promise(function (resolve, reject) {
    setTimeout(function () {
       // resolve('ones')
                resolve('ones')
    }, 1000)
})
var p2 = new Promise(function (resolve, reject) {
    setTimeout(function () {
        // throw new Error('eeeee');
        //reject('two')
    resolve('two')
    }, 1000)
})
var getp3 = () => new Promise(function (resolve, reject) {
    setTimeout(function () {
        reject('three')
    }, 1000)
})

p1.then(function(result){
    console.log("--------", result)
        // return p2.then(function(res){console.log(res)}).catch(function(err){console.log(err)})
        return p2
}).then(function(p2result){
    console.log("=========", p2result)
    return getp3();
}).then(function(p3result){
    console.log('*********', p3result)
}).catch(function(err){
    console.log("CaughtCathchError", err)
})