promise.try vs promise.resolve error handling

Question

I've been looking at bluebird promises and how promise.try differs from a promise.resolve.then when an error is thrown. Firstly some code using promise.try where it throws a synchronous error

Promise.try(function() {
    throw new Error('error');
}).catch(function(e) {
    console.log(e);
});

secondly some code which throws a synchronous error on resolve

Promise.resolve().then(function() {
    throw new Error('error');
}).catch(function(e) {
    console.log(e);
});

As far as I'm aware they both behave the same. Is promise.try essentially a cleaner way of resolving the promise?

The docs says promise.try:

will catch all errors in their Promise .catch handlers instead of having to handle both synchronous and asynchronous exception flows.

In the case of the example given in the docs:

function getUserById(id) {
    return Promise.try(function() {
        if (typeof id !== "number") {
            throw new Error("id must be a number");
        }
        return db.getUserById(id);
    });
}

if the synchronous error is thrown the asynchronous code will never be reached. Would there be any difference if you put the code above in a promise.resolve().then(..)?

Any clarification/examples of promise.try will be much appreciated.

Answer 1

As far as I'm aware they both behave the same.

Yes, mostly. However, the .then(…) callback will be invoked asynchronously, while Promise.try is synchronously executing your function.

Is promise.try essentially a cleaner way of resolving the promise?

Yes, it does provide a cleaner (less confusing) notation. But it's more of an optimisation, because it doesn't create any Promise.resolve(undefined) in the first place.

Answer 2

Adding to Bergi's answer: Promise.try is for those times you can't use Promise.method. The goal is to avoid cases where you have sync exceptions mixed with rejections.

Generally, whenever you're considering using Promise.try give Promise.method a spin.

var fn = Promise.method(function(){
    // can throw or return here, and it'll behave correctly
});

Is roughly the same as:

var fn = function(){
     return Promise.try(function(){
        // can throw or return here, and it'll behave correctly
     });
});