Why async patterns are critical in Node.js in Node.js - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to read a file asynchronously using Node.js built-in module.

Node.js

import { readFile } from 'fs/promises';

async function readData() {
  const data = await readFile('[1]', 'utf8');
  console.log(data);
}

readData();

Drag options to blanks, or click blank then click option'

A'./data.txt'

B'data.txt'

C'./data.json'

D'data.json'

Attempts:

3 left

💡 Hint

Common Mistakes

Omitting './' causes file not found errors.

Using synchronous readFileSync instead of async readFile.

The path './data.txt' correctly points to the file in the current directory. Using await with readFile reads the file asynchronously.

2fill in blank

medium

Complete the code to handle an asynchronous operation with a callback in Node.js.

Node.js

import { readFile } from 'fs';

readFile('[1]', 'utf8', (err, data) => {
  if (err) {
    console.error(err);
    return;
  }
  console.log(data);
});

Drag options to blanks, or click blank then click option'

A'file.json'

B'./file.txt'

C'./file.json'

D'file.txt'

Attempts:

3 left

💡 Hint

Common Mistakes

Using synchronous readFileSync instead of async readFile.

Incorrect file path causing errors.

The path './file.txt' correctly points to the file in the current directory. The callback handles the asynchronous read operation.

3fill in blank

hard

Fix the error in the async function to properly catch errors using try-catch.

Node.js

import { readFile } from 'fs/promises';

async function loadFile() {
  [1] {
    const content = await readFile('./info.txt', 'utf8');
    console.log(content);
  } catch (error) {
    console.error('Error:', error);
  }
}

loadFile();

Drag options to blanks, or click blank then click option'

Afinally

Bcatch

Ctry

Dawait

Attempts:

3 left

💡 Hint

Common Mistakes

Using catch without try causes syntax errors.

Not handling errors leads to unhandled promise rejections.

The try block is needed to wrap the await call so errors can be caught in the catch block.

4fill in blank

hard

Fill both blanks to create a Promise that resolves after a delay and use async/await to wait for it.

Node.js

function delay(ms) {
  return new Promise(([1], reject) => {
    setTimeout(() => [2](), ms);
  });
}

async function run() {
  console.log('Start');
  await delay(1000);
  console.log('End after 1 second');
}

run();

Drag options to blanks, or click blank then click option'

Aresolve

Breject

Cresolve()

Dreject()

Attempts:

3 left

💡 Hint

Common Mistakes

Calling reject() instead of resolve() causes the Promise to fail.

Not calling resolve() leaves the Promise pending forever.

The Promise constructor receives resolve and reject functions. Calling resolve() inside setTimeout signals the Promise is done.

5fill in blank

hard

Fill all three blanks to create an async function that fetches JSON data and handles errors.

Node.js

import fetch from 'node-fetch';

async function getData(url) {
  try {
    const response = await fetch([1]);
    if (!response.ok) throw new Error('Network error');
    const data = await response.[2]();
    return [3];
  } catch (err) {
    console.error('Fetch failed:', err);
  }
}

Drag options to blanks, or click blank then click option'

Aurl

Bjson

Cdata

Dtext

Attempts:

3 left

💡 Hint

Common Mistakes

Using response.text() instead of response.json() for JSON data.

Not returning the parsed data from the function.

The fetch function takes the URL. The response.json() method parses JSON data. Returning data gives the caller the fetched content.

Practice

1. Why are async patterns important in Node.js?

easy

A. They are only needed for database connections.

B. They make the code run slower but more securely.

C. They allow Node.js to use multiple CPU cores automatically.

D. They prevent blocking the main thread, keeping the app responsive.

Solution

1. Step 1: Understand Node.js single-thread model

   Node.js runs on a single main thread, so blocking operations freeze the app.

2. Step 2: Role of async patterns

   Async patterns let Node.js handle tasks without waiting, keeping it responsive.

3. Final Answer:

   They prevent blocking the main thread, keeping the app responsive. -> Option D

4. Quick Check:

   Async = Non-blocking main thread [OK]

Hint: Async avoids freezing by not blocking main thread [OK]

Common Mistakes:

• Thinking async makes code slower
• Believing Node.js uses multiple cores automatically
• Assuming async is only for databases

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

easy

A. async function myFunc() {}

B. async myFunc function() {}

C. function myFunc async() {}

D. function async myFunc() {}

Solution

1. Step 1: Recall async function syntax

   The correct syntax places async before the function keyword.

2. Step 2: Check each option

   Only async function myFunc() {} correctly writes async function myFunc() {}.

3. Final Answer:

   async function myFunc() {} -> Option A

4. Quick Check:

   async before function keyword [OK]

Hint: Put async before function keyword [OK]

Common Mistakes:

• Placing async after function name
• Using async inside parentheses
• Mixing order of async and function

3. What will the following Node.js code output?

async function fetchData() {
  return 'data';
}

fetchData().then(console.log);
console.log('start');

medium

A. data\nstart

B. start

C. start\ndata

D. data

Solution

1. Step 1: Understand async function return

   Async functions return a promise resolved with the value 'data'.

2. Step 2: Execution order of promises and console.log

   console.log('start') runs immediately, then the promise resolves and logs 'data'.

3. Final Answer:

   start\ndata -> Option C

4. Quick Check:

   Sync logs before async promise [OK]

Hint: Sync logs print before async promise resolves [OK]

Common Mistakes:

• Assuming async return logs immediately
• Thinking promise blocks next line
• Confusing order of console.log calls

4. Identify the error in this Node.js async code snippet:

async function readFile() {
  const data = fs.readFileSync('file.txt');
  console.log(data);
}

medium

A. Missing await keyword before fs.readFileSync call.

B. Using synchronous readFileSync inside async function blocks event loop.

C. fs.readFileSync does not exist in Node.js.

D. Async functions cannot use console.log.

Solution

1. Step 1: Check usage of fs.readFileSync

   readFileSync is synchronous and blocks the event loop, which is bad in async functions.

2. Step 2: Understand async function best practices

   Async functions should use non-blocking calls like fs.promises.readFile with await.

3. Final Answer:

   Using synchronous readFileSync inside async function blocks event loop. -> Option B

4. Quick Check:

   Sync calls block event loop in async code [OK]

Hint: Avoid sync calls inside async functions [OK]

Common Mistakes:

• Thinking await works with sync functions
• Believing readFileSync is async
• Assuming console.log is disallowed in async

5. You want to fetch data from two APIs in Node.js and combine results. Which async pattern best ensures both calls run at the same time and you wait for both results before continuing?

hard

A. Use Promise.all with both API calls and await the combined promise.

B. Call both APIs without await and process results immediately.

C. Call one API, await it, then call the second API and await it.

D. Use setTimeout to delay the second API call after the first.

Solution

1. Step 1: Understand sequential vs parallel calls

   Awaiting one API before calling the second runs them sequentially, slowing total time.

2. Step 2: Use Promise.all for parallel execution

   Promise.all runs both calls simultaneously and waits for both to finish before continuing.

3. Final Answer:

   Use Promise.all with both API calls and await the combined promise. -> Option A

4. Quick Check:

   Promise.all runs async calls in parallel [OK]

Hint: Use Promise.all to await multiple async calls together [OK]

Common Mistakes:

• Running calls sequentially causing delays
• Not awaiting promises causing undefined results
• Using setTimeout for async control