Practice Questions — Asynchronous JavaScript - Callbacks, Promises, Async/Await

function delay(ms) {
  return new Promise(function(resolve) {
    setTimeout(resolve, ms);
  });
}

async function main() {
  console.log('A');
  await delay(1000);
  console.log('B');
  await delay(1000);
  console.log('C');
}

main();

function countdown(n) {
  return new Promise(function(resolve) {
    let current = n;
    console.log(current);
    const timer = setInterval(function() {
      current--;
      if (current > 0) {
        console.log(current);
      } else {
        clearInterval(timer);
        resolve('done');
      }
    }, 1000);
  });
}

countdown(3).then(result => console.log(result));

function loadUser(name) {
  return new Promise(resolve => {
    setTimeout(() => resolve({ name, loaded: true }), 500);
  });
}

async function sequentialLoad(names) {
  console.time('sequential');
  const results = [];
  for (const name of names) {
    results.push(await loadUser(name));
  }
  console.timeEnd('sequential');
  return results;
}

async function parallelLoad(names) {
  console.time('parallel');
  const results = await Promise.all(names.map(loadUser));
  console.timeEnd('parallel');
  return results;
}

async function main() {
  await sequentialLoad(['Aarav', 'Priya', 'Rohan']);
  await parallelLoad(['Aarav', 'Priya', 'Rohan']);
}
main();

function delay(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function retryWithDelay(fn, maxRetries, delayMs) {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      const result = await fn();
      console.log('Attempt ' + attempt + ': success!');
      return result;
    } catch (error) {
      console.log('Attempt ' + attempt + ': failed, retrying in ' + delayMs + 'ms');
      if (attempt === maxRetries) throw error;
      await delay(delayMs);
    }
  }
}

let callCount = 0;
async function unreliable() {
  callCount++;
  if (callCount < 3) throw new Error('not ready');
  return 'data';
}

retryWithDelay(unreliable, 5, 500).then(r => console.log('Got:', r));

async function runAll(tasks) {
  const promises = tasks.map(fn => fn());
  const results = await Promise.allSettled(promises);

  return {
    total: results.length,
    succeeded: results.filter(r => r.status === 'fulfilled').length,
    failed: results.filter(r => r.status === 'rejected').length,
    results: results
  };
}

async function main() {
  const report = await runAll([
    () => Promise.resolve('data1'),
    () => Promise.reject('error1'),
    () => Promise.resolve('data2'),
    () => Promise.reject('error2')
  ]);
  console.log('Total:', report.total);
  console.log('Succeeded:', report.succeeded);
  console.log('Failed:', report.failed);
}
main();

function withTimeout(promise, ms) {
  const timeout = new Promise(function(_, reject) {
    setTimeout(function() {
      reject(new Error('Timeout after ' + ms + 'ms'));
    }, ms);
  });
  return Promise.race([promise, timeout]);
}

function slowOperation() {
  return new Promise(resolve => setTimeout(() => resolve('done'), 5000));
}

function fastOperation() {
  return new Promise(resolve => setTimeout(() => resolve('done'), 500));
}

async function main() {
  try {
    const result = await withTimeout(fastOperation(), 2000);
    console.log('Fast:', result);
  } catch (e) {
    console.log('Fast error:', e.message);
  }

  try {
    const result = await withTimeout(slowOperation(), 2000);
    console.log('Slow:', result);
  } catch (e) {
    console.log('Slow error:', e.message);
  }
}
main();

class AsyncQueue {
  constructor() {
    this.queue = [];
    this.running = false;
  }

  add(asyncFn) {
    return new Promise((resolve, reject) => {
      this.queue.push({ fn: asyncFn, resolve, reject });
      if (!this.running) {
        this.process();
      }
    });
  }

  async process() {
    this.running = true;
    while (this.queue.length > 0) {
      const { fn, resolve, reject } = this.queue.shift();
      try {
        const result = await fn();
        resolve(result);
      } catch (error) {
        reject(error);
      }
    }
    this.running = false;
  }
}

const queue = new AsyncQueue();
function delay(ms, val) {
  return new Promise(r => setTimeout(() => r(val), ms));
}

queue.add(() => delay(1000, 'A')).then(v => console.log(v, Date.now()));
queue.add(() => delay(500, 'B')).then(v => console.log(v, Date.now()));
queue.add(() => delay(300, 'C')).then(v => console.log(v, Date.now()));

function simulateFetch(url) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (url.includes('fail')) reject(new Error('Network error'));
      else resolve({ data: 'Result from ' + url });
    }, 1000);
  });
}

async function fetchWithLoading(url, statusEl) {
  statusEl.textContent = 'Loading...';
  try {
    const result = await simulateFetch(url);
    statusEl.textContent = 'Success: ' + result.data;
    return result;
  } catch (error) {
    statusEl.textContent = 'Error: ' + error.message;
    return null;
  } finally {
    console.log('Loading complete for', url);
  }
}

// Usage:
// const el = document.getElementById('status');
// fetchWithLoading('/api/data', el);
// fetchWithLoading('/api/fail', el);