24

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.
    });
cdmckay
  • 31,832
  • 25
  • 83
  • 114
  • Seems like a design decision that is perfectly valid either way. – James Montagne Feb 12 '13 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 completing the promise with a certain value. – Explosion Pills Feb 12 '13 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 Feb 12 '13 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 Feb 12 '13 at 21:01

3 Answers3

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.

Frédéric Hamidi
  • 258,201
  • 41
  • 486
  • 479
2

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

ebsddd
  • 1,028
  • 9
  • 20
0

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.

Kevin B
  • 94,570
  • 16
  • 163
  • 180