Async/await syntax in Node.js - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the async keyword do when placed before a function?

It makes the function return a Promise automatically and allows the use of await inside it to pause execution until a Promise resolves.

beginner

How does the await keyword work inside an async function?

It pauses the function execution until the awaited Promise settles, then returns the resolved value or throws an error if rejected.

intermediate

Why should you use try/catch blocks with async/await?

Because await can throw errors if the Promise rejects, so try/catch helps handle those errors gracefully.

intermediate

What happens if you use await outside of an async function?

It causes a syntax error because await can only be used inside functions declared with async or in top-level modules supporting top-level await.

advanced

How can you run multiple asynchronous operations in parallel using async/await?

Start all Promises without awaiting them immediately, then use await Promise.all([...]) to wait for all to finish together.

What does the async keyword do to a function?

A Makes the function return a Promise

B Makes the function synchronous

C Prevents errors inside the function

D Automatically logs function output

The async keyword makes the function return a Promise, enabling the use of await inside.

Where can you use the await keyword?

A Anywhere in the code

B Only inside <code>async</code> functions or top-level modules

C Only inside <code>try/catch</code> blocks

D Only in synchronous functions

await can only be used inside async functions or in modules that support top-level await.

What is the best way to handle errors when using await?

A Use <code>setTimeout</code>

B Ignore errors

C Use <code>console.log</code> only

D Use <code>try/catch</code> blocks

Using try/catch blocks lets you catch and handle errors from rejected Promises when using await.

How do you run multiple async tasks in parallel with async/await?

A Start all Promises, then await <code>Promise.all</code>

B Await each Promise one after another

C Use <code>setInterval</code>

D Use nested <code>async</code> functions

Starting all Promises first and then awaiting Promise.all runs them in parallel efficiently.

What happens if an awaited Promise rejects and you don't catch the error?

A The function will ignore the error silently

B The Promise will resolve anyway

C The error will be unhandled and may crash the program

D The program will pause indefinitely

If you don't catch errors from rejected Promises, they remain unhandled and can crash your program.

Explain how async and await work together to handle asynchronous code in Node.js.

Think about how you wait for a friend to arrive before starting an activity.

Describe how to handle errors when using await in your code.

Imagine catching a ball so it doesn't fall and break.

Practice

1. What does the await keyword do inside an async function in Node.js?

easy

A. It converts a promise into a callback function.

B. It makes the function run faster by skipping the promise.

C. It stops the entire program until the promise finishes.

D. It pauses the function execution until the promise resolves or rejects.

Solution

1. Step 1: Understand the role of await

   The await keyword pauses the execution of the async function until the promise it waits for settles (resolves or rejects).

2. Step 2: Differentiate from blocking behavior

   This pause only affects the async function, not the entire program, allowing other code to run concurrently.

3. Final Answer:

   It pauses the function execution until the promise resolves or rejects. -> Option D

4. Quick Check:

   await pauses async function = C [OK]

Hint: Remember: await pauses only async function, not whole program [OK]

Common Mistakes:

• Thinking await blocks the entire program
• Confusing await with callbacks
• Believing await speeds up code by skipping promises

2. Which of the following is the correct syntax to declare an async function in Node.js?

easy

A. function async myFunc() {}

B. async function myFunc() {}

C. function myFunc async() {}

D. async: function myFunc() {}

Solution

1. Step 1: Recall async function declaration syntax

   In Node.js, the correct way to declare an async function is by placing the async keyword before the function keyword.

2. Step 2: Check each option

   async function myFunc() {} matches the correct syntax: async function myFunc() {}. Others are invalid syntax.

3. Final Answer:

   async function myFunc() {} -> Option B

4. Quick Check:

   async before function keyword = B [OK]

Hint: Put async right before function keyword to declare async function [OK]

Common Mistakes:

• Placing async after function name
• Using colons or other symbols incorrectly
• Writing async inside parentheses

3. What will be the output of the following code?

async function getNumber() {
  return 42;
}

async function main() {
  const result = await getNumber();
  console.log(result);
}

main();

medium

A. 42

B. Error: await used outside async function

C. undefined

D. Promise { 42 }

Solution

1. Step 1: Understand async function return values

   The function getNumber is async and returns 42, which means it returns a promise that resolves to 42.

2. Step 2: Await the promise in main

   The await keyword waits for the promise to resolve, so result gets the value 42, which is then logged.

3. Final Answer:

   42 -> Option A

4. Quick Check:

   await unwraps promise value = D [OK]

Hint: Await unwraps promise to get actual value inside async function [OK]

Common Mistakes:

• Expecting a Promise object printed
• Forgetting await causes Promise logged
• Using await outside async function

4. Identify the error in this code snippet:

async function fetchData() {
  const data = await fetch('https://api.example.com/data');
  return data.json();
}

fetchData().then(console.log);

medium

A. Missing await before data.json() call

B. fetch cannot be used in Node.js

C. async keyword is missing before fetchData

D. Cannot return data from async function

Solution

1. Step 1: Analyze the fetchData function

   The function awaits the fetch call, which returns a Response object. Calling data.json() returns a promise.

2. Step 2: Check promise handling for data.json()

   Since data.json() returns a promise, it should be awaited to get the parsed JSON before returning.

3. Final Answer:

   Missing await before data.json() call -> Option A

4. Quick Check:

   Await promises before returning parsed data = A [OK]

Hint: Await all promises inside async functions before returning [OK]

Common Mistakes:

• Not awaiting nested promises like data.json()
• Assuming fetch is unavailable in Node.js (modern Node supports it)
• Forgetting async keyword on async functions

5. You want to fetch user data and then fetch posts for that user sequentially using async/await. Which code snippet correctly handles errors and ensures posts are fetched only after user data is received?

async function getUserAndPosts() {
  try {
    const user = await fetchUser();
    const posts = await fetchPosts(user.id);
    return { user, posts };
  } catch (error) {
    console.error('Error fetching data:', error);
    return null;
  }
}

hard

A. fetchPosts runs before fetchUser completes

B. Does not handle errors because try/catch is missing

C. Correctly handles errors and fetches posts after user data

D. Returns posts without waiting for fetchPosts promise

Solution

1. Step 1: Check async/await sequence

   The code awaits fetchUser() first, then uses the user ID to await fetchPosts(), ensuring sequential execution.

2. Step 2: Verify error handling

   The try/catch block correctly catches any errors from either await call and logs them, returning null on failure.

3. Final Answer:

   Correctly handles errors and fetches posts after user data -> Option C

4. Quick Check:

   Try/catch with sequential await = A [OK]

Hint: Use try/catch around awaits to handle errors sequentially [OK]

Common Mistakes:

• Omitting try/catch for error handling
• Calling second await before first completes
• Returning promises without awaiting them