javascript - When should I reject a promise? - Stack Overflow

admin管理员组

文章数量:1244421

I'm writing some JS code that uses promises. For example, I open a form pop-up and I return a jQuery Deferred object. It works like this:

• If the user clicks OK on the form, and it validates, the Deferred resolves to an object representing the form data.

• If the user clicks Cancel, then the Deferred resolves to a null.

What I'm trying to decide is should the Deferred instead reject, instead of resolve? More generally, I'm wondering when should I resolve to something like a null object, and when should I reject?

Here's some code demonstrating the two positions:

// Resolve with null.
var promise = form.open()
    .done(function (result) {
        if (result) {
            // Do something with result.
        } else {
            // Log lack of result.
        }
    });

// Reject.
var promise = form.open()
    .done(function (result) {            
        // Do something with result.            
    })
    .fail(function () {
        // Log lack of result.
    });

I'm writing some JS code that uses promises. For example, I open a form pop-up and I return a jQuery Deferred object. It works like this:

• If the user clicks OK on the form, and it validates, the Deferred resolves to an object representing the form data.

• If the user clicks Cancel, then the Deferred resolves to a null.

What I'm trying to decide is should the Deferred instead reject, instead of resolve? More generally, I'm wondering when should I resolve to something like a null object, and when should I reject?

Here's some code demonstrating the two positions:

// Resolve with null.
var promise = form.open()
    .done(function (result) {
        if (result) {
            // Do something with result.
        } else {
            // Log lack of result.
        }
    });

// Reject.
var promise = form.open()
    .done(function (result) {            
        // Do something with result.            
    })
    .fail(function () {
        // Log lack of result.
    });

• javascript
• jquery
• jquery-deferred
• promise

Share Improve this question Follow asked Feb 12, 2013 at 20:54 cdmckaycdmckay 32.3k2525 gold badges8686 silver badges114114 bronze badges 4

• Seems like a design decision that is perfectly valid either way. – James Montagne Commented Feb 12, 2013 at 20:59
• I don't think that one method is better than the other, but I usually associate fail with something going wrong such as an exception rather than a chosen value, i.e. failure to be able to fulfill the promise rather than pleting the promise with a certain value. – Explosion Pills Commented Feb 12, 2013 at 20:59
• @ExplosionPills Yeah that's what I'm trying to get a handle on. So I should treat a promise rejection as the same severity as an exception? – cdmckay Commented Feb 12, 2013 at 21:01
• 1 @cdmckay Well .. there's not really a should about it, but at least that's what jQuery seems to do with the ajax deferred objects. – Explosion Pills Commented Feb 12, 2013 at 21:01

Add a ment  | 

3 Answers 3

Sorted by: Reset to default 4

The semantics of your two strategies are not really the same. Explicitly rejecting a deferred is meaningful.

For instance, $.when() will keep accumulating results as long as the deferred objects it is passed succeed, but will bail out at the first one which fails.

It means that, if we rename your two promises promise1 and promise2 respectively:

$.when(promise1, promise2).then(function() {
    // Success...
}, function() {
    // Failure...
});

The code above will wait until the second form is closed, even if the first form is canceled, before invoking one of the callbacks passed to then(). The invoked callback (success or failure) will only depend on the result of the second form.

However, that code will not wait for the first form to be closed before invoking the failure callback if the second form is canceled.

Since it's user-controlled, I wouldn't treat it as a "failure". The first option seems cleaner.

Well, in both cases you would do something different, so i would say always either resolve it, or reject it. Do your form post on resolve, and on reject do nothing. Then, on always, close the form.

var promise = form.open()
.done(function (result) {            
    // Do something with result.            
})
.fail(function () {
    // Log lack of result.
})
.always(function() {
    // close the form.
})

If you aren't rejecting on cancel, when are you ever rejecting at all? at that point, why use a deferred object? You could reject on input error, but then you would have to generate a whole new promise if you wanted to allow them to fix it.

---

Deferreds don't really seem like the right thing to use here. I'd just use events.

本文标签： javascriptWhen should I reject a promiseStack Overflow