Async & Promises

const p1 = Promise.resolve("fast");
const p2 = new Promise(r => setTimeout(() => r("slow"), 500));
const p3 = Promise.reject(new Error("failed"));

// Promise.all — resolves when ALL resolve; rejects if ANY rejects:
await Promise.all([p1, p2]);          // ["fast", "slow"]
await Promise.all([p1, p3]);          // throws — p3 rejected

// Promise.allSettled — waits for ALL, never rejects:
const results = await Promise.allSettled([p1, p2, p3]);
results.forEach(r => {
  if (r.status === "fulfilled") console.log("✓", r.value);
  else                          console.log("✗", r.reason.message);
});

// Promise.race — resolves/rejects with the FIRST to settle:
await Promise.race([p1, p2]);   // "fast" — p1 won

// Promise.any — resolves with the FIRST to FULFILL (ignores rejections):
await Promise.any([p3, p2]);    // "slow" — p3 rejected, p2 fulfilled
// If ALL reject: throws AggregateError

// Centralised error handling — one try/catch around a workflow:
async function loadDashboard(userId) {
  try {
    const [user, posts, settings] = await Promise.all([
      fetchUser(userId),
      fetchPosts(userId),
      fetchSettings(userId),
    ]);
    return { user, posts, settings };
  } catch (e) {
    // Any of the three can cause this catch to fire
    console.error("Dashboard load failed:", e.message);
    return null;
  }
}

// Per-operation fallback — don't let one failure kill everything:
async function loadWithFallback(userId) {
  const user  = await fetchUser(userId).catch(() => null);
  const posts = await fetchPosts(userId).catch(() => []);  // empty array fallback
  return { user, posts };
}

// Paginated API — process pages one at a time:
async function* fetchPages(url) {
  let page = 1;
  while (true) {
    const res  = await fetch(`${url}?page=${page}`);
    const data = await res.json();
    if (data.length === 0) return;
    yield data;
    page++;
  }
}

for await (const page of fetchPages("/api/items")) {
  page.forEach(item => console.log(item.name));
}

// ✗ Forgetting to await — common silent bug:
async function wrong() {
  const data = fetchUser(1);  // returns a Promise, not the user!
  console.log(data.name);     // undefined — Promise has no .name
}

// ✗ await inside forEach — forEach doesn't await:
async function wrongLoop() {
  const ids = [1, 2, 3];
  ids.forEach(async id => {
    const user = await fetchUser(id);   // these run in parallel, order not guaranteed
    console.log(user.name);
  });
}

// ✓ Use for...of for sequential async loops:
async function rightLoop() {
  const ids = [1, 2, 3];
  for (const id of ids) {
    const user = await fetchUser(id);   // waits for each before next
    console.log(user.name);
  }
}

console.log("1 — sync");

setTimeout(() => console.log("4 — macrotask"), 0);

Promise.resolve()
  .then(() => console.log("2 — microtask 1"))
  .then(() => console.log("3 — microtask 2"));

console.log("1b — still sync");

// Output: 1 → 1b → 2 → 3 → 4
// Microtasks drain completely before the next macrotask

// async function roughly desugars to:
async function f() {
  const x = await getX();
  return x + 1;
}
// ≈
function f() {
  return getX().then(x => x + 1);
}

// Unhandled rejection tracking — engines track Promises that are rejected
// but have no rejection handler at the end of a microtask checkpoint.
// This fires window.unhandledrejection / process.unhandledRejection.

// Timeout wrapper — race the real request against a timeout:
function withTimeout(promise, ms) {
  const timeout = new Promise((_, reject) =>
    setTimeout(() => reject(new Error(`Timed out after ${ms}ms`)), ms)
  );
  return Promise.race([promise, timeout]);
}

// Retry with exponential backoff:
async function withRetry(fn, maxAttempts = 3, baseDelay = 100) {
  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
    try {
      return await fn();
    } catch (e) {
      if (attempt === maxAttempts) throw e;
      await new Promise(r => setTimeout(r, baseDelay * 2 ** (attempt - 1)));
    }
  }
}