![](https://cdn-images-1.medium.com/max/2000/1*wBiJ82CJVPCyymYYzN1I9Q.png)

I recently read a medium post where the author claimed that using `async-await` is better than using `promises.` While this might hold good in general cases, I think that generalisation was too broad and doesn’t do justice to either `async-await` or `promises.` For somebody who is new to Javascript making sense of these and decide which one to use can be a challenge. In this post I will list down things that I have learnt about these and how I decide when to use what.

I read somewhere that `async-await` is syntactical sugar for using `promises`. So before getting to know `async-await` or deciding on which approach to you use make sure that you have a better understanding of promises. I captured my learnings in the post [Understanding promises in Javascript](https://hackernoon.com/understanding-promises-in-javascript-13d99df067c1). If you do not have time to go through the full article checkout the thumb rules that I follow.

### Thumb Rules for using Promises

![](https://cdn-images-1.medium.com/max/1600/1*0mBlni5vsYZE2wFzfVv8EA.png)

1.  Use promises whenever you are using asynchronous or blocking code.
2.  `resolve` maps to `then` and `reject` maps to `catch` for all practical purposes.
3.  Make sure to write both `.catch` and `.then` methods for all the promises.
4.  If something needs to be done in both the cases use `.finally`
5.  We only get one shot at mutating each promise.
6.  We can add multiple handlers to a single promise.
7.  The return type of all the methods in `Promise` object whether they are static methods or prototype methods is again a `Promise`
8.  In `Promise.all` the order of the promises are maintained in values variable irrespective of which promise was first resolved.

* * *

Once you have wrapped your head around promises checkout `async await.` It helps you to write code that is much more readable. When not used properly it has its downsides. You can read [Understanding async-await in Javascript](https://hackernoon.com/understanding-async-await-in-javascript-1d81bb079b2c) to checkout my learnings. If you do not have time to read the full article checkout my thumb rules.

### Thumb Rules for async-await

Here are a list of thumb rules I use to keep my head sane around using `async`and `await`

1.  `aync` functions returns a promise.
2.  `async` functions use an implicit Promise to return its result. Even if you don’t return a promise explicitly `async` function makes sure that your code is passed through a promise.
3.  `await` blocks the code execution within the `async` function, of which it(`await statement`) is a part.
4.  There can be multiple `await` statements within a single `async` function.
5.  When using `async await` make sure to use `try catch` for error handling.
6.  Be extra careful when using `await` within loops and iterators. You might fall into the trap of writing sequentially executing code when it could have been easily done in parallel.
7.  `await` is always for a single promise.
8.  Promise creation starts the execution of asynchronous functionality.
9.  `await` only blocks the code execution within the `async` function. It only makes sure that next line is executed when the `promise` resolves. So if an asynchronous activity has already started then `await` will not have an effect on it.

* * *

### So should I use promises or async-await

The answer is that we will use both. Following are the thumb rules I use to decide when to use `promises` and when to use `async await`

1.  `async function` returns a `promise.` The converse is also true. Every function that returns a `promise` can be considered as `async function`
2.  `await` is used for calling an `async function` and wait for it to `resolve` or `reject`.
3.  `await` blocks the execution of the code within the `async` function in which it is located.
4.  If the output of `function2` is dependent on output of `function1` then I use `await`.
5.  If two functions can be run in parallel create two different `async functions` and then run them in parallel.
6.  Two run promises in parallel create an array of promises and then use `Promise.all(promisesArray)`
7.  Every time you use `await` remember that you are writing blocking code. Over the time we tend to neglect this.
8.  Instead of creating huge `async functions` with many `await asyncFunction()` in it, it is better to create smaller `async functions.` This way we will be aware of not writing too much of blocking code.
9.  Another advantage of using smaller `async functions` is that you force yourself to think what are the async functions that can be run in parallel.
10.  If your code contains blocking code it is better to make it an `async`function. By doing this you are making sure that somebody else can use your function asynchronously.
11.  By making async functions out of blocking code, you are enabling the user who will call your function to decide on the level of asynhronicity he wants.

Hope this helps you decide easily when to use promises and when to use `promises` and when to use`async-await`

If you liked this article and would like to read similar articles, don’t forget to clap. There is a limit of 50 claps on medium. Do check it out.

<hr/>

### Other Related Articles
1. [Understanding Promises in Javascript](https://steemit.com/utopian-io/@gokulnk/understanding-promises-in-javascript)
2. [Understanding async-await in Javascript](https://steemit.com/javascript/@gokulnk/understanding-async-await-in-javascript)
3. [Understanding npm in Nodejs](https://steemit.com/javascript/@gokulnk/understanding-npm-in-nodejs)