Asynchronous Programming in JavaScript: Promises

JavaScript is a single-threaded programming system. However, a lot of tasks are performed asynchronously by the host environment. Async tasks do not follow the ordinary flow of the program, because it is not determined when they will be resolved or if they will encounter an error.

For doing an async task, you need to use a callback function in the very least. However, if you are going to do several async tasks in tandem, your nested callbacks will soon make the program unreadable or unmaintainble. This is where promises come in.

A promise is an object with a then method that is called when an async task has been resolved or rejected.

In order to create a promise, you can use the Promise constructor. For example:

    let promise = new Promise((resolve, reject) => {
        try {
            let result = asyncTask();
            resolve(result);
        } catch(e) {
            reject(e);
        }
    })

The promise has a then method that accepts two parameters:

    .then(onResolve, onReject)

If the promise is resolved, the onResolve handler is called with the result. If there was an error, the onReject handler is called with the reason of rejection.

There is also a catch method that handles only the rejection cases:

    .catch(onReject)

On the other hand, the promise has also a finally method with a handler that is called after the promise has been either resolved or rejected:

    .finally(handler)

Promises are especially useful for chaining several async tasks:

    Promise.resolve(a)
    .then(a => asyncTaskA(a))
    .then(b => asyncTaskB(b))
    .then(c => asyncTaskC(c))
    .catch(e => console.log(e))
    .finally(() => cleanUp());

The promises make an elegant solution for dealing with async tasks. However, there is a newer method for this purpose, namely the async and await keywords, that I will discuss in the next post.