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

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why does Node.js use asynchronous patterns?

Node.js is built to handle many tasks at once without waiting for each to finish. Why is this important?

A Because Node.js needs to run multiple threads simultaneously to work.

B Because Node.js runs on a single thread and async patterns prevent blocking it.

C Because synchronous code is faster and preferred in Node.js.

D Because async patterns make Node.js code shorter but slower.

💡 Hint

Think about how Node.js handles many users at the same time.

Node.js uses a single thread to handle many tasks. Async patterns let it start a task and move on without waiting, so it doesn't get stuck.

❓ component_behavior

intermediate

What happens when you use synchronous file reading in Node.js?

Consider this code snippet that reads a file synchronously in Node.js. What is the effect on the server?

Node.js

const fs = require('fs');
console.log('Start');
const data = fs.readFileSync('file.txt', 'utf8');
console.log(data);
console.log('End');

A The server waits for the file to be read before continuing, blocking other tasks.

B The server reads the file in the background and continues immediately.

C The server throws an error because synchronous reading is not allowed.

D The server reads the file asynchronously but logs output in order.

💡 Hint

Think about what 'Sync' means in the function name.

readFileSync blocks the single thread until the file is fully read, stopping other tasks from running during that time.

❓ state_output

advanced

What is the output order of this async code?

Look at this Node.js code using async patterns. What will be printed first?

Node.js

console.log('A');
setTimeout(() => console.log('B'), 0);
Promise.resolve().then(() => console.log('C'));
console.log('D');

A 'A', 'C', 'D', 'B'

B 'D', 'A', 'B', 'C'

C 'A', 'B', 'C', 'D'

D 'A', 'D', 'C', 'B'

💡 Hint

Remember the order of synchronous code, microtasks, and macrotasks.

Console logs 'A' and 'D' synchronously. Promise.then runs next (microtask), printing 'C'. setTimeout runs last (macrotask), printing 'B'.

📝 Syntax

advanced

Which option correctly uses async/await in Node.js?

Choose the code snippet that correctly uses async/await to read a file.

A

const fs = require('fs/promises');
async function read() {
  const data = fs.readFileSync('file.txt', 'utf8');
  console.log(data);
}
read();

B

const fs = require('fs');
async function read() {
  const data = fs.readFile('file.txt', 'utf8');
  console.log(await data);
}
read();

C

const fs = require('fs/promises');
async function read() {
  const data = await fs.readFile('file.txt', 'utf8');
  console.log(data);
}
read();

D

const fs = require('fs/promises');
function read() {
  const data = await fs.readFile('file.txt', 'utf8');
  console.log(data);
}
read();

💡 Hint

Remember that await can only be used inside async functions and with promises.

Option C correctly imports fs/promises, uses async function, and awaits the promise returned by readFile.

🔧 Debug

expert

Why does this async function never finish?

Consider this Node.js async function. Why does it never log 'Done'?

Node.js

async function process() {
  setTimeout(() => {
    console.log('Timeout done');
  }, 1000);
  console.log('Start');
  await new Promise(() => {});
  console.log('Done');
}
process();

A Because the awaited promise never resolves or rejects, so 'Done' is never logged.

B Because console.log('Done') is outside the async function.

C Because setTimeout blocks the event loop for 1 second, delaying 'Done'.

D Because the function process is never called.

💡 Hint

Look at the promise passed to await. Does it ever finish?

The promise passed to await has an empty executor and never calls resolve or reject, so the function waits forever.