Promise protips - stuff I wish I had known when I started with Promises

protips.js

// Promise.all is good for executing many promises at once
Promise.all([
  promise1,
  promise2
]);

// Promise.resolve is good for wrapping synchronous code
Promise.resolve().then(function () {
  if (somethingIsNotRight()) {
    throw new Error("I will be rejected asynchronously!");
  } else {
    return "This string will be resolved asynchronously!";
  }
});

// execute some promises one after the other.
// this takes an array of promise factories, i.e.
// an array of functions that RETURN a promise
// (not an array of promises themselves; those would execute immediately)
function sequentialize(promiseFactories) {
  var chain = Promise.resolve();
  promiseFactories.forEach(function (promiseFactory) {
    chain = chain.then(promiseFactory);
  });
  return chain;
}

// Promise.race is good for setting a timeout:
Promise.race([
  new Promise(function (resolve, reject) {
    setTimeout(reject, 10000); // timeout after 10 secs
  }),
  doSomethingThatMayTakeAwhile()
]);

// Promise finally util similar to Q.finally
// e.g. promise.then(...).catch().then(...).finally(...)
function finally (promise, cb) {
  return promise.then(function (res) {
    var promise2 = cb();
    if (typeof promise2.then === 'function') {
      return promise2.then(function () {
        return res;
      });
    }
    return res;
  }, function (reason) {
    var promise2 = cb();
    if (typeof promise2.then === 'function') {
      return promise2.then(function () {
        throw reason;
      });
    }
    throw reason;
  });
};

@nolanlawson Can you explain how the above factory promise is working in depth. It will help many developers.

@nolanlawson
Sorry if I've missed the point, but finally() isn't a function on the Promise type, so the example in the comment doesn't work. So, how do you use it? Wrap the whole thing in the function call? Kinda kills the beauty of the promise chain. Add it to the Promise prototype?

Thanks.

Great Article!

Here's a tip for if you want to use Promise.all but want something nicer than an array to hold the final values:

Promise.all({
    foo: doSomething(),
    bar: doSomethingElse(),
    quux: doAnotherThing().then(q => q.property)
}).then(values => {
    const { foo, bar, quux } = values
    // now you have the result of foo, bar, and quux (including the transformation on quux from the "then" that it had)
})

nice article!

Great article, still a rookie to understand promises and make useful application of the concepts.

👍 awesome promise article

Thanks for that :-D

putYourRightFootIn()
  .then(putYourRightFootOut)
  .then(putYourRightFootIn)  
  .then(shakeItAllAbout);

Taken from your enlightening easy to read blog post.

What's a good use case for wrapping synchronous code with a Promise?