Javascript 功能上的拒绝承诺

在javascript中，如何拒绝承诺？简单地返回

新错误（'blah'）

不起作用，错误控制台抛出“.then不是函数”或类似的东西

所以我加入了Promise.jsm，然后

返回了Promise.reject（新错误（'blah'））

所以我的问题是：如果我的承诺是：那么我就不必返回Promise.rjet，只需返回新错误，对吗

 //mainPromise chains to promise0 and chains to promise1
function doPromise(rejectRightAway) {
    if (rejectRightAway) {
        return Promise.reject(new Error('intending to throw mainPromise rejection')); //is this right place to use Promise.reject? //returning just new Error throws in error console, something like: '.then is not a function' and points to the onReject function of mainPromise.then
    }

    promise0.then(
        function () {

            var promise1 = somePromiseObject;
            promise1.then(
                function () {
                    alert('promise1 success');
                },
                function (aRejReason) {
                    alert('promise1 rejected ' + aRejReason.message);
                    return new Error('promise1 rejected so through promise0 rej then mainPromise rej'); //want to throw promise1 rejection //ok to just return new Error?
                }
            );
        },
        function (aRejReason) {
            alert('promise0 rejected with reason = ' + aRejReason.message);
        }
    );

    return promise0;

}

var mainPromise = doPromise();
mainPromise.then(
    function () {
        alert('mainPromise success');
    },
    function (aRejectReason) {
        alert('mainPromise rejected with reason = ' + aRejectReason.message)
    }
);

---

我不确定这个代码是否有效，所以我的问题是如何拒绝——比如什么时候返回

Promise.reject（new Error（））

正确，什么时候只返回

new Error（）

？

您需要拒绝特定的承诺：

return promise0.reject(new Error('intending to throw mainPromise rejection'));

tl:dr

• 为了指示操作的正常完成，您将返回其结果

  返回结果

• 为了指示异常，您

  抛出新错误（原因）

  就像在同步代码中一样，承诺是安全抛出的
• 可以从链中显式返回拒绝，但通常是不需要的

---

promises的一大优点是它们修复了异步代码中的异常处理

承诺不仅仅是对并发的顺序一元DSL的抽象-它们也是安全的

抛出安全性在这方面真的很棒，您可以像您在顺序代码中一样：

function foo(){
    if(somethingWrong){
        // instead of returning normally, we throw, using the built in exception chain
        // code blocks have. This indicates something unexpected breaking the sequence of cour code
        throw new Error("Something was wrong");
    }
    return "some normal result"; // here we indicate a function terminated normally,
                                 // and with which value.
}

节点中的回调使用了

（err，result…

约定，我觉得这很难看。通过承诺，您可以再次获得顺序代码中错误处理的好处：

somePromise.then(function(){
     if(rejectRightAway){
          throw new Error("rejecting right away...");
     }
     return "some normal result";
})....

看看它和顺序代码有多相似？每当你想拒绝你从then处理程序中抛出你的

时，每当你想实现你从then处理程序中返回的时候。就像在“同步”代码中一样

因此，在你的情况下：

//want to throw promise1 rejection //ok to just return new Error?
return new Error('promise1 rejected so through promise0 rej then mainPromise rej'); 

完全按照您直觉上想要做的事情来解决：

 throw new Error("promise1 rejected so through promise0 rej then mainPromise rej");

啊，仅仅返回新错误不会启动拒绝链？@Noitidart正确，您需要拒绝承诺。啊，好的，如果我返回了
promise.reject（
而不是
promise0.reject
它能识别我要拒绝的承诺吗？我不能做
main承诺。reject
在
rejectRightAway
子句中，它抛出一个奇怪的错误，说
然后不是一个函数
你不能做
承诺。reject
因为它不能告诉你要拒绝什么承诺。我不确定为什么在你的问题中有两个承诺，为什么不在第一个承诺后附加
。然后在
s？注意一些库（即$q）处理
throw
语句比处理
$q.reject
语句更为严厉。reject返回并将它们记录到控制台。如果库无法跟踪未处理的拒绝，那么将错误记录到控制台对您来说实际上是一件好事。