Memo related with Promise

Promise is a kind of object that when executed, it can be either resolved or rejected.

promise.then([onFulfilled], [onRejected])

how to create a Promise

new Promise((resolve, reject) => {  


  })

the argument to initialize a promise is a function with two parameters. resolve, and reject, both are functions.

how to turn a function with callback into a promise ?

// function fetchURL(url, callback);
// function parsePage(content, callback);
let fetch = new Promise((resolve, reject) => {  
    fetchURL(url, (err,result)=>{
      if(err){return reject(err);
      } else {
        return resolve(result);
      }
      })
  })
  let parse = new Promise((resolve, reject) => {  
      parsePage(content, (err,result)=>{
        if(err){return reject(err);
        } else {
          return resolve(result);
        }
        })
    })

then instead of calling

fetchURL("https://google.com", (err,content)=>{
  parsePage(content, (err, result)=>{
    //do something here
  })
})

we can write something like

fetch("https://google.com").then(
  (result)=> parse(result)
  ).then((result)=>{
    //do something with the result;
  }
)

then callback hell is turned into promise chain.

promisify

There exists a general way to turn callback-based function into one that returns a promise.

module.exports.promisify = function(callbackBasedApi) {
  return function promisified() {
    const args = [].slice.call(arguments);
    return new Promise((resolve, reject) => {        
      args.push((err, result) => {                   
        if(err) {
          return reject(err);                       
        }
        if(arguments.length <= 2) {                
          resolve(result);
        } else {
          resolve([].slice.call(arguments, 1));
        }
      });
      callbackBasedApi.apply(null, args);
    });
  }
};

create a function called promisified, which return a promise.

in the promise initialize function, we push a callback function into the arguments into promisified and use the new arguments to call callbackBasedApi, in the callback we pushed into arguments, it use resolve and reject to fullfill a the promise.

Sequential Iteration

let tasks = [ /* ... */ ]
let promise = Promise.resolve();
tasks.forEach(task => {
  promise = promise.then(() => {
    return task();
  });
});
promise.then(() => {
  //All tasks completed
});

or instead of forEach, use reduce.

let tasks = [ /* ... */ ]
let promise = tasks.reduce((prev, task) => {
  return prev.then(() => {
    return task();
  });
}, Promise.resolve());


promise.then(() => {
  //All tasks completed
});

Both use a Promise.resove() to kick the first iteration.

Parallel execution

let promises = [ /* promises */ ]


Promise.all(promises).then(() => {
  //All tasks completed
});