Promises and async

A promise is a value that is not ready yet. await waits for it.

async function load(id: string): Promise<User> {
  const res = await fetch(`/api/users/${id}`);
  if (!res.ok) throw new Error(`HTTP ${res.status}`);
  return res.json() as Promise<User>;
}

An async function always returns a promise, whatever you write inside it. Returning 5 returns Promise<number>.

The try/catch that never catches

try {
  sendWelcomeEmail(user.email);   // no await
} catch (err) {
  logger.warn(err);               // never runs
}

try guards the synchronous execution of its block. The call returns a promise immediately, the block finishes, and the rejection arrives later with nothing on the stack to catch it — as an unhandled rejection, which under Node's default policy takes the process down.

The fix is await. Every promise should be awaited, returned, or explicitly discarded with a comment saying why it is fire-and-forget. A bare promise used as a statement always deserves a second look.

Sequential against parallel

const a = await loadUser(id);     // waits
const b = await loadOrders(id);   // then waits again

Those two do not depend on each other, so waiting twice wastes the first wait. Promise.all starts both and waits once:

const [a, b] = await Promise.all([loadUser(id), loadOrders(id)]);

Fifty sequential calls at 500 microseconds each is 25 milliseconds of pure waiting. In parallel it is closer to one round trip.

Promise.all rejects as soon as any one rejects. When you want every result including the failures, Promise.allSettled gives you both.

Try it

1// Each call logs when it starts and when it finishes, so the output2// shows how the waits overlap without depending on the clock.3function slow(label: string, log: string[]): Promise<void> {4  log.push(`start ${label}`);5  return new Promise((resolve) =>6    setTimeout(() => {7      log.push(`end ${label}`);8      resolve();9    }, 20),10  );11}12 13export async function run(): Promise<Record<string, string>> {14  const sequential: string[] = [];15  await slow("a", sequential);16  await slow("b", sequential);17  await slow("c", sequential);18 19  const parallel: string[] = [];20  await Promise.all([slow("a", parallel), slow("b", parallel), slow("c", parallel)]);21 22  return { sequential: sequential.join(", "), parallel: parallel.join(", ") };23}

forEach does not wait

forEach calls your callback and throws away whatever it returns — including the promise an async callback returns. Nothing waits for it:

1function wait(ms: number): Promise<number> {2  return new Promise((resolve) => setTimeout(() => resolve(ms), ms));3}4 5export async function run(): Promise<number[]> {6  let viaForEach = 0;7  [10, 20, 30].forEach(async (ms) => {8    viaForEach += await wait(ms);   // forEach ignores the promise this returns9  });10  const rightAfterForEach = viaForEach;11 12  let viaForOf = 0;13  for (const ms of [10, 20, 30]) {14    viaForOf += await wait(ms);     // the loop itself waits15  }16 17  // By now the forEach callbacks have finished too; nobody waited for them.18  return [rightAfterForEach, viaForOf, viaForEach];19}

Use for...of with await when the steps must happen in order, or await Promise.all(items.map(async ...)) when they may overlap.

Common mistakes

• forEach with an async callback. Shown above: the total is 0 when the code moves on, and a shared += across awaits loses updates as well.
• Calling without await inside try. The rejection arrives after the try has finished, so the catch never runs.
• Awaiting independent calls one after another. Correct, but each wait is added to the last; Promise.all overlaps them.
• Expecting Promise.all to cancel the rest. When one rejects, the others keep running; their results are simply ignored. Promises have no built-in cancellation.

What interviewers ask

• What happens when an async function throws? It does not throw at the call site; it returns a rejected promise, seen only by await or .