Async Patterns

// Callback hell: deeply nested, hard to follow
fs.readFile('a.txt', (err, a) => {
  fs.readFile('b.txt', (err, b) => {
    fs.readFile('c.txt', (err, c) => {
      console.log(a, b, c);
    });
  });
});

Common follow-ups: What does 'error-first' mean in the error-first callback convention, and why was it adopted?;How would util.promisify() convert an existing callback-based function to return a promise instead?

const promise = new Promise((resolve, reject) => {
  setTimeout(() => {
    const success = Math.random() > 0.5;
    success ? resolve('Data loaded') : reject(new Error('Load failed'));
  }, 1000);
});

promise.then(result => console.log(result)).catch(err => console.error(err.message));

Common follow-ups: What happens if resolve() is called after reject() has already been called on the same promise?;How does Promise.prototype.finally() differ from adding logic inside both .then() and .catch()?

const results = await Promise.allSettled([
  fetch('/api/a'), fetch('/api/b'), fetch('/api/c')
]);
results.forEach(r => r.status === 'fulfilled' ? console.log(r.value) : console.error(r.reason));

// Promise.race for a timeout pattern
const result = await Promise.race([fetchData(), timeout(5000)]);

Common follow-ups: How would you implement a request timeout using Promise.race()?;What's a scenario where Promise.any() is specifically the right choice over Promise.race()?

async function getUserData(id) {
  try {
    const user = await fetchUser(id); // pauses this function only, not the whole program
    const posts = await fetchPosts(user.id);
    return { user, posts };
  } catch (err) {
    console.error('Failed to load user data:', err.message);
    throw err;
  }
}

Common follow-ups: What happens if you forget the 'await' keyword before a promise-returning call inside an async function?;Why does an unhandled rejection inside an async function not crash the process the same way a synchronous throw would, without additional handling?

// Sequential: total time = taskA time + taskB time
const a = await taskA();
const b = await taskB();

// Concurrent: total time = max(taskA time, taskB time)
const [a2, b2] = await Promise.all([taskA(), taskB()]);

Common follow-ups: In what specific scenario is sequential awaiting actually the correct choice rather than a mistake?;How does this concurrency differ from true parallelism, given Node.js still runs on a single main thread?

async function* fetchAllPages(url) {
  let nextUrl = url;
  while (nextUrl) {
    const response = await fetch(nextUrl);
    const page = await response.json();
    yield page.items;
    nextUrl = page.nextPageUrl;
  }
}

for await (const items of fetchAllPages('/api/users')) {
  console.log(`Got a page of ${items.length} users`);
}

Common follow-ups: How do async generators relate to Node.js readable streams, given both represent asynchronous sequences of data?;What happens if the consuming 'for await...of' loop is exited early with a break -- does the generator clean up properly?

process.on('uncaughtException', (err) => {
  console.error('Uncaught exception, shutting down:', err);
  process.exit(1); // cleanup only, never suppress and continue
});

process.on('unhandledRejection', (reason) => {
  console.error('Unhandled rejection:', reason);
  process.exit(1);
});

Common follow-ups: Why is it considered bad practice to use these handlers to simply swallow the error and let the process keep running?;How do you prevent a specific promise from ever becoming an unhandled rejection in the first place?

async function retryWithBackoff(fn, maxRetries = 5, baseDelay = 200) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await fn();
    } catch (err) {
      if (attempt === maxRetries - 1) throw err;
      const delay = baseDelay * 2 ** attempt + Math.random() * 100;
      await new Promise(resolve => setTimeout(resolve, delay));
    }
  }
}

Common follow-ups: Which types of errors should actually be retried versus failed immediately (like a 400 Bad Request versus a 503 Service Unavailable)?;How does adding jitter specifically help prevent a 'thundering herd' problem?

const util = require('node:util');
const fs = require('node:fs');

const readFileAsync = util.promisify(fs.readFile);
const data = await readFileAsync('config.json', 'utf-8');

// Modern alternative: many core modules now ship promise versions directly
const fsPromises = require('node:fs/promises');
const data2 = await fsPromises.readFile('config.json', 'utf-8');

Common follow-ups: What convention must a callback-based function follow for util.promisify() to work correctly on it?;How do you handle a callback-based function that doesn't follow the standard error-first convention?

// Broken: doesn't wait for any of the async operations
items.forEach(async (item) => { await processItem(item); });
console.log('Done!'); // logs immediately, before any items are actually processed

// Fixed: use a for...of loop for sequential processing
for (const item of items) { await processItem(item); }
console.log('Done!'); // correctly logs only after all items are processed

// Or Promise.all with map() for concurrent processing
await Promise.all(items.map(item => processItem(item)));

Common follow-ups: Why does map() work correctly with async callbacks when combined with Promise.all(), while forEach() doesn't work in the same pattern?;What's the performance tradeoff between the for...of sequential approach and the Promise.all with map concurrent approach?