Promise-patterns.md

JS Prmise Pattern

Table of contents

• Promise for sequential
• Promise for sequential (programmatically)
• Promise.all for Parallel
• Promise.all between
• Promise.defer
• Promise.resolve
• Promise.race
• Promise.reduce with bluebird

Promise for sequential - A specific number of times

function foo1() {
  return new Promise(function(resolve, reject) {
    resolve("foo1");
  });
}
function foo2(str) {
  return new Promise(function(resolve, reject) {
    resolve([str, "foo2"]);
  });
}
function foo3(array) {
  return new Promise(function(resolve, reject) {
    resolve([...array, "foo3"]);
  });
}
foo1().then(function(result) {
  return foo2(result);
}).then(function(results) {
  return foo3(results);
}).then(function(results) {
  console.log(results);
  // => [ 'foo1', 'foo2', 'foo3' ]
}).catch(function(error){
  console.log(error);
});

Promise for sequential - For programmatically

const tasks = _.times(3, num => {
  return () => {
    return new Promise(function (resolve) {
      setTimeout(() => {
        console.log(num);
        resolve(num);
      }, Math.random() * 1000);
    });
  }
});

tasks.reduce((previousPromise, nextPromise) => {
  return previousPromise.then(nextPromise);
}, Promise.resolve()).then(function() {
  console.log("Finished!");
}).catch((err) => {
  console.log("Failed.", err);
});
=> 0
   1
   3
   Finished!

Promise.all between

function foo1() {
  return new Promise(function(resolve, reject) {
    resolve("foo1");
  });
}
function foo2() {
  return new Promise(function(resolve, reject) {
    resolve("foo2");
  });
}
function foo3() {
  return new Promise(function(resolve, reject) {
    resolve("foo3");
  });
}
foo1().then(function(result) {
  return Promise.all([
    Promise.resolve(result),
    foo2(),
    foo3(),
  ]);
}).then(function(results) {
  console.log(results);
  // => [ 'foo1', 'foo2', 'foo3' ]
}).catch(function(error){
  console.log(error);
});

Dynamically sequential Promises

function createPromise(params, results) {
  return new Promise(function(resolve, reject) {
    resolve((results || []).concat([`${params}ret`]));
  });
}
Promise.resolve().then(function() {
  return createPromise("start");
}).then(function(results) {
  return createPromise("finished", results);
})
.then(function(results) {
  console.log(results);
  // => [ 'startret', 'finishedret' ]
});

Promise.all for Parallel

E.g.Resolve

function foo1() {
  return new Promise(function(resolve, reject) {
    resolve("foo1");
  });
}
function foo2() {
  return new Promise(function(resolve, reject) {
    resolve("foo2");
  });
}
function foo3() {
  return new Promise(function(resolve, reject) {
    resolve("foo3");
  });
}
Promise.all([foo1(), foo2(), foo3()]).then(function(results){
  console.log(results);
  // => [ 'foo1', 'foo2', 'foo3' ]
}).catch(function(error){
  console.log(error)
});

E.g.Reject

function foo1() {
  return new Promise(function(resolve, reject) {
    resolve("foo1");
  });
}
function foo2() {
  return new Promise(function(resolve, reject) {
    reject("foo2"); // change 'reject' from 'resolve'
  });
}
function foo3() {
  return new Promise(function(resolve, reject) {
    resolve("foo3");
  });
}
Promise.all([foo1(), foo2(), foo3()]).then(function(results){
  console.log(results);
}).catch(function(error){
  console.log(error)
  // => 'foo2'
});

Promise.defer

No nesting.

function foo1() {
  var deferred = Promise.defer();
  deferred.resolve("foo1");
  return deferred.promise;
}

function foo2() {
  var deferred = Promise.defer();
  deferred.resolve("foo2");
  return deferred.promise;
}

Promise.all([foo1(), foo2()]).then(function(results){
  console.log(results);
  // => [ 'foo1', 'foo2' ]
}).catch(function(error){
});

Promise.resolve

Always returns resolve. There is also Promise.reject.

function foo() {
  return new Promise(function(resolve, reject) {
    resolve("foo");
  });
}
Promise.all([
  Promise.resolve("start"), 
  foo(),
  Promise.resolve("finished")
]).then(function(results){
  console.log(results);
  // => [ 'start', 'foo', 'finished' ]
}).catch(function(error){
  console.log(error)
});

Promise.resolve("start"),
// => Same as below
Promise.resolve({
  then: function(resolve) {resolve("start")}
})

Promise.race

Only the first return result.

var foo1 = new Promise(function(resolve, reject) {
  setTimeout(function() {
    resolve("success");
  }, 1000);
});

var foo2 = new Promise(function(resolve, reject) {
  setTimeout(function() {
    resolve("fail");
  }, 100);
});

Promise.race([foo1, foo2]).then(function(ret) {
  console.log(ret);
  // => fail
});

Promise.reduce with bluebird

var Promise = require('bluebird');

Promise.reduce(["My","name","is","nakanori"], (accumulator, str, i) => {
  return new Promise((resolve, reject) => {
    resolve(`${accumulator} ${str}`);
  });
}, "")
.then((ret) => {
  console.log(ret);
  // =>  My name is nakanori
})
.catch((error) => {
});