Advanced Async Patterns — Series 2

Preview — 3 of 10 questions

What happens here? The server responds after 500 ms.

javascript

try {
  const res = await fetch('/slow-api', {
    signal: AbortSignal.timeout(100),
  });
  console.log('ok');
} catch (e) {
  console.log(e.name);
}

A'ok' is logged after 500 ms.

B'AbortError' is logged after ~100 ms.

C'TimeoutError' is logged after ~100 ms.

D'TypeError' is logged immediately.

What is a practical risk of the following pattern? If fn keeps calling scheduleWork recursively:

javascript

function scheduleWork(fn) {
  Promise.resolve().then(fn);
}

AA stack overflow, because promises use the call stack.

BMacrotasks (I/O, timers) are starved — they never get a turn.

CMemory leaks, because microtasks are never garbage collected.

DNo risk — microtasks yield to macrotasks between each tick.

What is the resolved/rejected value of result?

javascript

const result = await Promise.all([
  Promise.resolve(1),
  Promise.reject('boom'),
  Promise.resolve(3),
]).catch(e => `caught: ${e}`);

console.log(result);

A[1, undefined, 3]

B'caught: boom'

C[1, 'boom', 3]

DUnhandled rejection

Answer all 10 questions (7 more), see explanations for every answer, and track your score.