# Async/await in Node.js

Source: https://tpiros.dev/blog/async-await-in-node-js

How to use async/await when working with asynchronous Node.js code.

> Async/await is available as part of Node.js since version 7.10.1 (or since version 7.5 with the `--harmony` flag.

## From callbacks to promises

In a previous article we covered [why promises are a great addition to JavaScript](http://fullstack-developer.academy/promises-in-javascript/).

Asynchronous programming in Node.js started with the event loop and error-first callbacks. It works, but callbacks bring problems that can cost you sleep.

Native Promise support in Node.js helped by giving asynchronous code a better execution flow. But you still end up with callbacks inside `then()` blocks when a promise resolves, or inside `catch()` blocks when one rejects.

## Making promises even better

The `async` and `await` keywords give developers an even cleaner way to control asynchronous code execution. They let you write code that reads synchronously, with minimal syntax.

> If native callbacks were causing callback hell, then async/await is really callback heaven.

To use async/await you still need Promises underneath, so make sure you understand how those work.

> The `await` keyword can only be used inside functions declared with the `async` keyword.

As the name suggests, `await` pauses execution until a promise settles. If it resolves, the result can be stored in a variable. If it rejects, you catch it with a `catch` statement. That means an `async` function should ideally wrap its logic in a `try/catch` block.

## async/await

Here's a good use case: multiple promises chained together. Imagine making two API calls and constructing a message from both responses. With plain promises:

```javascript
const request = require('request');

function makeRequest(url) {
  return new Promise((resolve, reject) => {
    request(url, (error, response, body) => {
      if (error) {
        reject(error);
      }
      resolve(JSON.parse(body));
    });
  });
}

let message;
makeRequest('https://swapi.co/api/people/1')
  .then((character) => {
    message = `${character.name} played in`;
    return makeRequest(character.films[0]);
  })
  .then((film) => {
    message += ` ${film.title}.`;
    return message;
  })
  .then((message) => console.log(message))
  .catch((error) => console.error(error));
```

Constructing the final message looks tangled. With `async/await`, the same logic reads much more cleanly. The only thing we keep from the previous example is the `makeRequest()` method:

```javascript
const request = require('request');

function makeRequest(url) {
  return new Promise((resolve, reject) => {
    request(url, (error, response, body) => {
      if (error) {
        reject(error);
      }
      resolve(JSON.parse(body));
    });
  });
}

async function message() {
  try {
    const character = await makeRequest('https://swapi.co/api/people/1');
    const film = await makeRequest(character.films[0]);
    console.log(`${character.name} played in ${film.title}`);
  } catch (error) {
    console.log(error);
  }
}

message();
```

Both `await` calls pause until their promise resolves. The first `character` variable (already holding resolved data) feeds straight into the second request.

The code is more readable, easier to follow, and trivial to add breakpoints to.