āĻ…ā§āϝāĻžāϏāĻŋāĻ™ā§āĻ• āĻĢāĻžāĻ‚āĻļāύ: āĻĒā§āϰāϤāĻŋāĻļā§āϰ⧁āϤāĻŋ āĻŦāĻ¨ā§āϧ⧁āĻ¤ā§āĻŦāĻĒā§‚āĻ°ā§āĻŖ āĻ•āϰāĻž

āĻ…ā§āϝāĻžāϏāĻŋāĻ™ā§āĻ• āĻĢāĻžāĻ‚āĻļāύāϗ⧁āϞāĻŋ āφāĻĒāύāĻžāϕ⧇ āĻĒā§āϰāϤāĻŋāĻļā§āϰ⧁āϤāĻŋ-āĻ­āĻŋāĻ¤ā§āϤāĻŋāĻ• āϕ⧋āĻĄ āϞāĻŋāĻ–āϤ⧇ āĻĻ⧇āϝāĻŧ āϝ⧇āύ āĻāϟāĻŋ āϏāĻŋāĻ™ā§āĻ•ā§āϰ⧋āύāĻžāϏāĨ¤

Async āĻĢāĻžāĻ‚āĻļāύāϗ⧁āϞāĻŋ Chrome, Edge, Firefox āĻāĻŦāĻ‚ Safari-āĻ āĻĄāĻŋāĻĢāĻ˛ā§āϟāϰ⧂āĻĒ⧇ āϏāĻ•ā§āϰāĻŋāϝāĻŧ āĻ•āϰāĻž āĻšāϝāĻŧ āĻāĻŦāĻ‚ āϏ⧇āϗ⧁āϞāĻŋ āĻŦ⧇āĻļ āĻ¸ā§āĻĒāĻˇā§āϟāϤāχ āĻ…āϏāĻžāϧāĻžāϰāĻŖāĨ¤ āϤāĻžāϰāĻž āφāĻĒāύāĻžāϕ⧇ āĻĒā§āϰāϤāĻŋāĻļā§āϰ⧁āϤāĻŋ-āĻ­āĻŋāĻ¤ā§āϤāĻŋāĻ• āϕ⧋āĻĄ āϞ⧇āĻ–āĻžāϰ āĻ…āύ⧁āĻŽāϤāĻŋ āĻĻ⧇āϝāĻŧ āϝ⧇āύ āĻāϟāĻŋ āϏāĻŋāĻ™ā§āĻ•ā§āϰ⧋āύāĻžāϏ, āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻŽā§‚āϞ āĻĨā§āϰ⧇āĻĄ āĻŦā§āϞāĻ• āύāĻž āĻ•āϰ⧇āĨ¤ āϤāĻžāϰāĻž āφāĻĒāύāĻžāϰ āĻ…ā§āϝāĻžāϏāĻŋāĻ™ā§āĻ•ā§āϰ⧋āύāĻžāϏ āϕ⧋āĻĄ āĻ•āĻŽ "āϚāϤ⧁āϰ" āĻāĻŦāĻ‚ āφāϰāĻ“ āĻĒāĻžāĻ āϝ⧋āĻ—ā§āϝ āĻ•āϰ⧇ āϤ⧋āϞ⧇āĨ¤

Async āĻĢāĻžāĻ‚āĻļāύ āĻāχ āĻŽāϤ āĻ•āĻžāϜ āĻ•āϰ⧇:

async function myFirstAsyncFunction() {
  try {
    const fulfilledValue = await promise;
  } catch (rejectedValue) {
    // â€Ļ
  }
}

āφāĻĒāύāĻŋ āϝāĻĻāĻŋ āĻāĻ•āϟāĻŋ āĻĢāĻžāĻ‚āĻļāύ āϏāĻ‚āĻœā§āĻžāĻžāϰ āφāϗ⧇ async āϕ⧀āĻ“āϝāĻŧāĻžāĻ°ā§āĻĄ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇āύ, āϤāĻžāĻšāϞ⧇ āφāĻĒāύāĻŋ āĻĢāĻžāĻ‚āĻļāύ⧇āϰ āĻŽāĻ§ā§āϝ⧇ await āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āύāĨ¤ āφāĻĒāύāĻŋ āϝāĻ–āύ āĻāĻ•āϟāĻŋ āĻĒā§āϰāϤāĻŋāĻļā§āϰ⧁āϤāĻŋāϰ await , āϤāĻ–āύ āĻĒā§āϰāϤāĻŋāĻļā§āϰ⧁āϤāĻŋ āĻ¸ā§āĻĨāĻŋāϰ āύāĻž āĻšāĻ“āϝāĻŧāĻž āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āĻĢāĻžāĻ‚āĻļāύāϟāĻŋ āĻāĻ•āϟāĻŋ āύāύ-āĻŦā§āϞāĻ•āĻŋāĻ‚ āωāĻĒāĻžāϝāĻŧ⧇ āĻŦāĻŋāϰāĻžāĻŽ āĻĻ⧇āĻ“āϝāĻŧāĻž āĻšāϝāĻŧāĨ¤ āĻĒā§āϰāϤāĻŋāĻļā§āϰ⧁āϤāĻŋ āĻĒā§‚āϰāĻŖ āĻšāϞ⧇, āφāĻĒāύāĻŋ āĻŽā§‚āĻ˛ā§āϝ āĻĢāĻŋāϰ⧇ āĻĒāĻžāĻŦ⧇āύāĨ¤ āĻĒā§āϰāϤāĻŋāĻļā§āϰ⧁āϤāĻŋ āĻĒā§āϰāĻ¤ā§āϝāĻžāĻ–ā§āϝāĻžāύ āĻ•āϰāϞ⧇, āĻĒā§āϰāĻ¤ā§āϝāĻžāĻ–ā§āϝāĻžāύ āĻ•āϰāĻž āĻŽāĻžāύ āύāĻŋāĻ•ā§āώ⧇āĻĒ āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤

āĻŦā§āϰāĻžāωāϜāĻžāϰ āϏāĻŽāĻ°ā§āĻĨāύ

Browser Support

  • āĻ•ā§āϰ⧋āĻŽ: 55āĨ¤
  • āĻĒā§āϰāĻžāĻ¨ā§āϤ: 15āĨ¤
  • āĻĢāĻžāϝāĻŧāĻžāϰāĻĢāĻ•ā§āϏ: 52āĨ¤
  • āϏāĻžāĻĢāĻžāϰāĻŋ: 10.1āĨ¤

Source

āωāĻĻāĻžāĻšāϰāĻŖ: āĻāĻ•āϟāĻŋ āφāύāϝāĻŧāύ āϞāĻ—āĻŋāĻ‚

āĻŦāϞ⧁āύ āφāĻĒāύāĻŋ āĻāĻ•āϟāĻŋ URL āφāύāϤ⧇ āϚāĻžāύ āĻāĻŦāĻ‚ āĻĒāĻžāĻ ā§āϝ āĻšāĻŋāϏāĻžāĻŦ⧇ āĻĒā§āϰāϤāĻŋāĻ•ā§āϰāĻŋāϝāĻŧāĻž āϞāĻ— āĻ•āϰ⧁āύ⧎ āĻĒā§āϰāϤāĻŋāĻļā§āϰ⧁āϤāĻŋ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ āĻāϟāĻŋ āϕ⧀āĻ­āĻžāĻŦ⧇ āĻĻ⧇āĻ–āĻžāϝāĻŧ āϤāĻž āĻāĻ–āĻžāύ⧇:

function logFetch(url) {
  return fetch(url)
    .then((response) => response.text())
    .then((text) => {
      console.log(text);
    })
    .catch((err) => {
      console.error('fetch failed', err);
    });
}

āĻāĻŦāĻ‚ āĻāĻ–āĻžāύ⧇ async āĻĢāĻžāĻ‚āĻļāύ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ āĻāĻ•āχ āϜāĻŋāύāĻŋāϏ:

async function logFetch(url) {
  try {
    const response = await fetch(url);
    console.log(await response.text());
  } catch (err) {
    console.log('fetch failed', err);
  }
}

āĻāϟāĻŋ āĻāĻ•āχ āϏāĻ‚āĻ–ā§āϝāĻ• āϞāĻžāχāύ, āĻ•āĻŋāĻ¨ā§āϤ⧁ āϏāĻŽāĻ¸ā§āϤ āĻ•āϞāĻŦā§āϝāĻžāĻ• āϚāϞ⧇ āϗ⧇āϛ⧇āĨ¤ āĻāϟāĻŋ āĻĒāĻĄāĻŧāĻž āϏāĻšāϜ āĻ•āϰ⧇ āϤ⧋āϞ⧇, āĻŦāĻŋāĻļ⧇āώ āĻ•āϰ⧇ āϝāĻžāϰāĻž āĻĒā§āϰāϤāĻŋāĻļā§āϰ⧁āϤāĻŋāϰ āϏāĻžāĻĨ⧇ āĻ•āĻŽ āĻĒāϰāĻŋāϚāĻŋāϤ āϤāĻžāĻĻ⧇āϰ āϜāĻ¨ā§āϝāĨ¤

Async āϰāĻŋāϟāĻžāĻ°ā§āύ āĻŽāĻžāύ

Async āĻĢāĻžāĻ‚āĻļāύ āϏāĻ°ā§āĻŦāĻĻāĻž āĻāĻ•āϟāĻŋ āĻĒā§āϰāϤāĻŋāĻļā§āϰ⧁āϤāĻŋ āĻĒā§āϰāĻĻāĻžāύ āĻ•āϰ⧇, āφāĻĒāύāĻŋ await āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧁āύ āĻŦāĻž āύāĻž āĻ•āϰ⧁āύāĨ¤ āϝ⧇ āĻĒā§āϰāϤāĻŋāĻļā§āϰ⧁āϤāĻŋ async āĻĢāĻžāĻ‚āĻļāύ āϰāĻŋāϟāĻžāĻ°ā§āύ āϝāĻžāχ āĻšā§‹āĻ• āύāĻž āϕ⧇āύ āϏāĻ™ā§āϗ⧇ āϏāĻŽāĻžāϧāĻžāύ, āĻŦāĻž async āĻĢāĻžāĻ‚āĻļāύ āύāĻŋāĻ•ā§āώ⧇āĻĒ āϝāĻžāχ āĻšā§‹āĻ• āύāĻž āϕ⧇āύ āϏāĻ™ā§āϗ⧇ āĻĒā§āϰāĻ¤ā§āϝāĻžāĻ–ā§āϝāĻžāύ. āϤāĻžāχ āĻāϰ āϏāĻžāĻĨ⧇:

// wait ms milliseconds
function wait(ms) {
  return new Promise((r) => setTimeout(r, ms));
}

async function hello() {
  await wait(500);
  return 'world';
}

â€Ļ hello() āĻ•āϞ āĻ•āϰāĻž āĻāĻ•āϟāĻŋ āĻĒā§āϰāϤāĻŋāĻļā§āϰ⧁āϤāĻŋ āĻĒā§āϰāĻĻāĻžāύ āĻ•āϰ⧇ āϝāĻž "world" āĻāϰ āϏāĻžāĻĨ⧇ āĻĒā§‚āϰāĻŖ āĻ•āϰ⧇ āĨ¤

async function foo() {
  await wait(500);
  throw Error('bar');
}

â€Ļ foo() āĻ•āϞ āĻ•āϰāĻž āĻāĻ•āϟāĻŋ āĻĒā§āϰāϤāĻŋāĻļā§āϰ⧁āϤāĻŋ āĻĒā§āϰāĻĻāĻžāύ āĻ•āϰ⧇ āϝāĻž Error('bar') āĻĻāĻŋāϝāĻŧ⧇ āĻĒā§āϰāĻ¤ā§āϝāĻžāĻ–ā§āϝāĻžāύ āĻ•āϰ⧇ āĨ¤

āωāĻĻāĻžāĻšāϰāĻŖ: āĻāĻ•āϟāĻŋ āĻĒā§āϰāϤāĻŋāĻ•ā§āϰāĻŋāϝāĻŧāĻž āĻ¸ā§āĻŸā§āϰāĻŋāĻŽāĻŋāĻ‚

āφāϰāĻ“ āϜāϟāĻŋāϞ āωāĻĻāĻžāĻšāϰāϪ⧇ āĻ…ā§āϝāĻžāϏāĻŋāĻ™ā§āĻ• āĻĢāĻžāĻ‚āĻļāύ⧇āϰ āϏ⧁āĻŦāĻŋāϧāĻž āĻŦ⧃āĻĻā§āϧāĻŋ āĻĒāĻžāϝāĻŧāĨ¤ āĻŦāϞ⧁āύ āφāĻĒāύāĻŋ āĻ…āĻ‚āĻļāϗ⧁āϞāĻŋ āϞāĻ— āφāωāϟ āĻ•āϰāĻžāϰ āϏāĻŽāϝāĻŧ āĻāĻ•āϟāĻŋ āĻĒā§āϰāϤāĻŋāĻ•ā§āϰāĻŋāϝāĻŧāĻž āĻ¸ā§āĻŸā§āϰāĻŋāĻŽ āĻ•āϰāϤ⧇ āĻšā§‡āϝāĻŧ⧇āĻ›āĻŋāϞ⧇āύ āĻāĻŦāĻ‚ āĻšā§‚āĻĄāĻŧāĻžāĻ¨ā§āϤ āφāĻ•āĻžāϰāϟāĻŋ āĻĢ⧇āϰāϤ āĻĻāĻŋāϤ⧇ āĻšā§‡āϝāĻŧ⧇āĻ›āĻŋāϞ⧇āύāĨ¤

āĻāĻ–āĻžāύ⧇ āĻāϟāĻŋ āĻĒā§āϰāϤāĻŋāĻļā§āϰ⧁āϤāĻŋ āϏāĻš:

function getResponseSize(url) {
  return fetch(url).then((response) => {
    const reader = response.body.getReader();
    let total = 0;

    return reader.read().then(function processResult(result) {
      if (result.done) return total;

      const value = result.value;
      total += value.length;
      console.log('Received chunk', value);

      return reader.read().then(processResult);
    });
  });
}

āφāĻŽāĻžāϕ⧇ āĻĻ⧇āϖ⧁āύ, āĻœā§āϝāĻžāĻ• "āĻĒā§āϰāϤāĻŋāĻļā§āϰ⧁āϤāĻŋāϰ āϚāĻžāϞāĻ•" āφāĻ°ā§āĻ•āĻŋāĻŦāĻ˛ā§āĻĄāĨ¤ āĻĻ⧇āϖ⧁āύ āĻ•āĻŋāĻ­āĻžāĻŦ⧇ āφāĻŽāĻŋ āĻāĻ•āϟāĻŋ āĻ…ā§āϝāĻžāϏāĻŋāĻ™ā§āĻ•ā§āϰ⧋āύāĻžāϏ āϞ⧁āĻĒ āϏ⧇āϟ āφāĻĒ āĻ•āϰāϤ⧇ āύāĻŋāĻœā§‡āϰ āĻ­āĻŋāϤāϰ⧇ processResult() āĻ•āϞ āĻ•āϰāĻ›āĻŋ? āϞ⧇āĻ–āĻžāϟāĻŋ āφāĻŽāĻžāϕ⧇ āϖ⧁āĻŦ āĻ¸ā§āĻŽāĻžāĻ°ā§āϟ āĻŽāύ⧇ āĻ•āϰ⧇āϛ⧇āĨ¤ āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻŦ⧇āĻļāĻŋāϰāĻ­āĻžāĻ— "āĻ¸ā§āĻŽāĻžāĻ°ā§āϟ" āϕ⧋āĻĄā§‡āϰ āĻŽāϤ⧋, āĻāϟāĻŋ āϕ⧀ āĻ•āϰāϛ⧇ āϤāĻž āĻŦā§‹āĻāĻžāϰ āϜāĻ¨ā§āϝ āφāĻĒāύāĻžāϕ⧇ āĻāϟāĻŋāϰ āĻĻāĻŋāϕ⧇ āϤāĻžāĻ•āĻŋāϝāĻŧ⧇ āĻĨāĻžāĻ•āϤ⧇ āĻšāĻŦ⧇, 90 āĻāϰ āĻĻāĻļāϕ⧇āϰ āϏ⧇āχ āĻŽā§āϝāĻžāϜāĻŋāĻ•-āφāχ āĻ›āĻŦāĻŋāϰ āĻŽāϤ⧋āĨ¤

āφāϏ⧁āύ āĻ…ā§āϝāĻžāϏāĻŋāĻ™ā§āĻ• āĻĢāĻžāĻ‚āĻļāύāϗ⧁āϞāĻŋāϰ āϏāĻžāĻĨ⧇ āφāĻŦāĻžāϰ āĻšā§‡āĻˇā§āϟāĻž āĻ•āϰāĻŋ:

async function getResponseSize(url) {
  const response = await fetch(url);
  const reader = response.body.getReader();
  let result = await reader.read();
  let total = 0;

  while (!result.done) {
    const value = result.value;
    total += value.length;
    console.log('Received chunk', value);
    // get the next result
    result = await reader.read();
  }

  return total;
}

āϏāĻŽāĻ¸ā§āϤ "āĻ¸ā§āĻŽāĻžāĻ°ā§āϟ" āϚāϞ⧇ āϗ⧇āϛ⧇āĨ¤ āĻ…ā§āϝāĻžāϏāĻŋāĻ™ā§āĻ•ā§āϰ⧋āύāĻžāϏ āϞ⧁āĻĒ āϝāĻž āφāĻŽāĻžāϕ⧇ āĻāϤ āĻ¸ā§āĻŽāĻžāĻ— āĻŦā§‹āϧ āĻ•āϰ⧇āϛ⧇ āĻāĻ•āϟāĻŋ āĻŦāĻŋāĻļā§āĻŦāĻ¸ā§āϤ, āĻŦāĻŋāϰāĻ•ā§āϤāĻŋāĻ•āϰ, āϝāĻ–āύ-āϞ⧁āĻĒ āĻĻāĻŋāϝāĻŧ⧇ āĻĒā§āϰāϤāĻŋāĻ¸ā§āĻĨāĻžāĻĒāĻŋāϤ āĻšāϝāĻŧ⧇āϛ⧇āĨ¤ āĻ…āύ⧇āĻ• āĻ­āĻžāϞ⧋āĨ¤ āĻ­āĻŦāĻŋāĻˇā§āϝāϤ⧇, āφāĻĒāύāĻŋ āĻ…ā§āϝāĻžāϏāĻŋāĻ™ā§āĻ• āχāϟāĻžāϰ⧇āϟāϰ āĻĒāĻžāĻŦ⧇āύ, āϝāĻž while āϞ⧁āĻĒāϕ⧇ āĻāĻ•āϟāĻŋ for-of āϞ⧁āĻĒ āĻĻāĻŋāϝāĻŧ⧇ āĻĒā§āϰāϤāĻŋāĻ¸ā§āĻĨāĻžāĻĒāύ āĻ•āϰāĻŦ⧇, āĻāϟāĻŋāϕ⧇ āφāϰāĻ“ āĻĒāϰāĻŋāĻˇā§āĻ•āĻžāϰ āĻ•āϰ⧇ āϤ⧁āϞāĻŦ⧇āĨ¤

āĻ…āĻ¨ā§āϝāĻžāĻ¨ā§āϝ āĻ…ā§āϝāĻžāϏāĻŋāĻ™ā§āĻ• āĻĢāĻžāĻ‚āĻļāύ āϏāĻŋāύāĻŸā§āϝāĻžāĻ•ā§āϏ

āφāĻŽāĻŋ āφāĻĒāύāĻžāϕ⧇ āχāϤāĻŋāĻŽāĻ§ā§āϝ⧇āχ async function() {} āĻĻ⧇āĻ–āĻŋāϝāĻŧ⧇āĻ›āĻŋ, āĻ•āĻŋāĻ¨ā§āϤ⧁ async āϕ⧀āĻ“āϝāĻŧāĻžāĻ°ā§āĻĄ āĻ…āĻ¨ā§āϝ āĻĢāĻžāĻ‚āĻļāύ āϏāĻŋāύāĻŸā§āϝāĻžāĻ•ā§āϏ⧇āϰ āϏāĻžāĻĨ⧇ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āϝ⧇āϤ⧇ āĻĒāĻžāϰ⧇:

āϤ⧀āϰ āĻĢāĻžāĻ‚āĻļāύ

// map some URLs to json-promises
const jsonPromises = urls.map(async (url) => {
  const response = await fetch(url);
  return response.json();
});

āĻ…āĻŦāĻœā§‡āĻ•ā§āϟ āĻĒāĻĻā§āϧāϤāĻŋ

const storage = {
  async getAvatar(name) {
    const cache = await caches.open('avatars');
    return cache.match(`/avatars/${name}.jpg`);
  }
};

storage.getAvatar('jaffathecake').then(â€Ļ);

āĻ•ā§āϞāĻžāϏ āĻĒāĻĻā§āϧāϤāĻŋ

class Storage {
  constructor() {
    this.cachePromise = caches.open('avatars');
  }

  async getAvatar(name) {
    const cache = await this.cachePromise;
    return cache.match(`/avatars/${name}.jpg`);
  }
}

const storage = new Storage();
storage.getAvatar('jaffathecake').then(â€Ļ);

āϏāĻžāĻŦāϧāĻžāύ! āϖ⧁āĻŦ āĻ•ā§āϰāĻŽāĻžāύ⧁āϏāĻžāϰ⧇ āϝāĻžāĻ“āϝāĻŧāĻž āĻāĻĄāĻŧāĻŋāϝāĻŧ⧇ āϚāϞ⧁āύ

āϝāĻĻāĻŋāĻ“ āφāĻĒāύāĻŋ āϕ⧋āĻĄ āϞāĻŋāĻ–āϛ⧇āύ āϝāĻž āϏāĻŋāĻ™ā§āĻ•ā§āϰ⧋āύāĻžāϏ āĻĻ⧇āĻ–āĻžāĻšā§āϛ⧇, āύāĻŋāĻļā§āϚāĻŋāϤ āĻ•āϰ⧁āύ āϝ⧇ āφāĻĒāύāĻŋ āϏāĻŽāĻžāĻ¨ā§āϤāϰāĻžāϞāĻ­āĻžāĻŦ⧇ āĻ•āĻŋāϛ⧁ āĻ•āϰāĻžāϰ āϏ⧁āϝ⧋āĻ— āĻŽāĻŋāϏ āĻ•āϰāĻŦ⧇āύ āύāĻžāĨ¤

async function series() {
  await wait(500); // Wait 500msâ€Ļ
  await wait(500); // â€Ļthen wait another 500ms.
  return 'done!';
}

āωāĻĒāϰ⧇āϰāϟāĻŋ āϏāĻŽā§āĻĒā§‚āĻ°ā§āĻŖ āĻšāϤ⧇ 1000ms āϞāĻžāϗ⧇, āϝ⧇āĻ–āĻžāύ⧇:

async function parallel() {
  const wait1 = wait(500); // Start a 500ms timer asynchronouslyâ€Ļ
  const wait2 = wait(500); // â€Ļmeaning this timer happens in parallel.
  await Promise.all([wait1, wait2]); // Wait for both timers in parallel.
  return 'done!';
}

āωāĻĒāϰ⧇āϰāϟāĻŋ āϏāĻŽā§āĻĒā§‚āĻ°ā§āĻŖ āĻšāϤ⧇ 500ms āϞāĻžāϗ⧇, āĻ•āĻžāϰāĻŖ āωāĻ­āϝāĻŧ āĻ…āĻĒ⧇āĻ•ā§āώāĻž āĻāĻ•āχ āϏāĻŽāϝāĻŧ⧇ āϘāĻŸā§‡āĨ¤ āĻāϰ āĻāĻ•āϟāĻŋ āĻŦāĻžāĻ¸ā§āϤāĻŦ āωāĻĻāĻžāĻšāϰāĻŖ āϤāĻžāĻ•āĻžāύ.

āωāĻĻāĻžāĻšāϰāĻŖ: āĻ•ā§āϰāĻŽāĻžāύ⧁āϏāĻžāϰ⧇ āφāωāϟāĻĒ⧁āϟ āĻ•āϰāĻž

āĻŦāϞ⧁āύ āφāĻĒāύāĻŋ āĻāĻ•āϟāĻŋ āϏāĻŋāϰāĻŋāϜ āχāωāφāϰāĻāϞ āφāύāϤ⧇ āϚāĻžāύ āĻāĻŦāĻ‚ āϝāϤ āϤāĻžāĻĄāĻŧāĻžāϤāĻžāĻĄāĻŧāĻŋ āϏāĻŽā§āĻ­āĻŦ āϏāĻ āĻŋāĻ• āĻ•ā§āϰāĻŽā§‡ āϞāĻ— āĻ•āϰāϤ⧇ āϚāĻžāύāĨ¤

āĻ—āĻ­ā§€āϰ āĻļā§āĻŦāĻžāϏ - āĻĒā§āϰāϤāĻŋāĻļā§āϰ⧁āϤāĻŋ āϏāĻš āĻāϟāĻŋ āĻĻ⧇āĻ–āϤ⧇ āϕ⧇āĻŽāύ:

function markHandled(promise) {
  promise.catch(() => {});
  return promise;
}

function logInOrder(urls) {
  // fetch all the URLs
  const textPromises = urls.map((url) => {
    return markHandled(fetch(url).then((response) => response.text()));
  });

  // log them in order
  return textPromises.reduce((chain, textPromise) => {
    return chain.then(() => textPromise).then((text) => console.log(text));
  }, Promise.resolve());
}

āĻšā§āϝāĻžāρ, āĻāϟāĻž āĻ āĻŋāĻ•, āφāĻŽāĻŋ āĻĒā§āϰāϤāĻŋāĻļā§āϰ⧁āϤāĻŋ āĻāĻ•āϟāĻŋ āĻ•ā§āϰāĻŽ āĻšā§‡āχāύ reduce āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻ›āĻŋ. āφāĻŽāĻŋ āϖ⧁āĻŦ āĻ¸ā§āĻŽāĻžāĻ°ā§āϟ . āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻāϟāĻŋ āĻāĻ•āϟāĻŋ āĻŦāĻŋāϟ āϤāĻžāχ āĻ¸ā§āĻŽāĻžāĻ°ā§āϟ āϕ⧋āĻĄāĻŋāĻ‚ āĻ›āĻžāĻĄāĻŧāĻž āφāĻĒāύāĻŋ āĻ­āĻžāϞ āĻŦāĻ¨ā§āϧ.

āϝāĻžāχāĻšā§‹āĻ•, āωāĻĒāϰ⧇āϰāϟāĻŋāϕ⧇ āĻāĻ•āϟāĻŋ āĻ…ā§āϝāĻžāϏāĻŋāĻ™ā§āĻ• āĻĢāĻžāĻ‚āĻļāύ⧇ āϰ⧂āĻĒāĻžāĻ¨ā§āϤāϰ āĻ•āϰāĻžāϰ āϏāĻŽāϝāĻŧ, āĻāϟāĻŋ āϖ⧁āĻŦ āĻ•ā§āϰāĻŽāĻžāύ⧁āϏāĻžāϰ⧇ āϝ⧇āϤ⧇ āϞ⧋āĻ­āύ⧀āϝāĻŧ:

āĻĒā§āϰāĻ¸ā§āϤāĻžāĻŦāĻŋāϤ āύāϝāĻŧ - āϖ⧁āĻŦ āĻ•ā§āϰāĻŽāĻŋāĻ•
async function logInOrder(urls) {
  for (const url of urls) {
    const response = await fetch(url);
    console.log(await response.text());
  }
}
āĻĻ⧇āĻ–āϤ⧇ āĻ…āύ⧇āĻ• āϏ⧁āĻ¨ā§āĻĻāϰ, āĻ•āĻŋāĻ¨ā§āϤ⧁ āφāĻŽāĻžāϰ āĻĒā§āϰāĻĨāĻŽ āφāύāĻž āϏāĻŽā§āĻĒā§‚āĻ°ā§āĻŖāϰ⧂āĻĒ⧇ āĻĒāĻĄāĻŧāĻž āύāĻž āĻšāĻ“āϝāĻŧāĻž āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āφāĻŽāĻžāϰ āĻĻā§āĻŦāĻŋāϤ⧀āϝāĻŧ āφāύāĻž āĻļ⧁āϰ⧁ āĻšāϝāĻŧ āύāĻž, āĻāĻŦāĻ‚ āϤāĻžāχāĨ¤ āĻāϟāĻŋ āĻĒā§āϰāϤāĻŋāĻļā§āϰ⧁āϤāĻŋāϰ āωāĻĻāĻžāĻšāϰāϪ⧇āϰ āϤ⧁āϞāύāĻžāϝāĻŧ āĻ…āύ⧇āĻ• āϧ⧀āϰ āϝāĻž āϏāĻŽāĻžāĻ¨ā§āϤāϰāĻžāϞāĻ­āĻžāĻŦ⧇ āĻĢ⧇āϚāϗ⧁āϞāĻŋ āϏāĻŽā§āĻĒāĻžāĻĻāύ āĻ•āϰ⧇⧎ āϏ⧌āĻ­āĻžāĻ—ā§āϝāĻ•ā§āϰāĻŽā§‡ āĻāĻ•āϟāĻŋ āφāĻĻāĻ°ā§āĻļ āĻŽāĻ§ā§āϝāĻŽ āĻ¸ā§āĻĨāϞ āφāϛ⧇.
āĻĒā§āϰāĻ¸ā§āϤāĻžāĻŦāĻŋāϤ - āϏ⧁āĻ¨ā§āĻĻāϰ āĻāĻŦāĻ‚ āϏāĻŽāĻžāĻ¨ā§āϤāϰāĻžāϞ
function markHandled(...promises) {
  Promise.allSettled(promises);
}

async function logInOrder(urls) {
  // fetch all the URLs in parallel
  const textPromises = urls.map(async (url) => {
    const response = await fetch(url);
    return response.text();
  });

  markHandled(...textPromises);

  // log them in sequence
  for (const textPromise of textPromises) {
    console.log(await textPromise);
  }
}
āĻāχ āωāĻĻāĻžāĻšāϰāϪ⧇, āχāωāφāϰāĻāϞāϗ⧁āϞāĻŋ āφāύāĻž āĻšāϝāĻŧ āĻāĻŦāĻ‚ āϏāĻŽāĻžāĻ¨ā§āϤāϰāĻžāϞāĻ­āĻžāĻŦ⧇ āĻĒāĻĄāĻŧāĻž āĻšāϝāĻŧ, āĻ•āĻŋāĻ¨ā§āϤ⧁ "āĻ¸ā§āĻŽāĻžāĻ°ā§āϟ" reduce āĻŦāĻŋāϟāϟāĻŋ āĻāĻ•āϟāĻŋ āĻ¸ā§āĻŸā§āϝāĻžāĻ¨ā§āĻĄāĻžāĻ°ā§āĻĄ, āĻŦāĻŋāϰāĻ•ā§āϤāĻŋāĻ•āϰ, āĻĒāĻĄāĻŧāĻžāϰ āϜāĻ¨ā§āϝ āϞ⧁āĻĒ āĻĻāĻŋāϝāĻŧ⧇ āĻĒā§āϰāϤāĻŋāĻ¸ā§āĻĨāĻžāĻĒāĻŋāϤ āĻšāϝāĻŧāĨ¤

āĻŦā§āϰāĻžāωāϜāĻžāϰ āϏāĻŽāĻ°ā§āĻĨāύ āϏāĻŽāĻžāϧāĻžāύ: āĻœā§‡āύāĻžāϰ⧇āϟāϰ

āφāĻĒāύāĻŋ āϝāĻĻāĻŋ āĻœā§‡āύāĻžāϰ⧇āϟāϰ āϏāĻŽāĻ°ā§āĻĨāύ āĻ•āϰ⧇ āĻāĻŽāύ āĻŦā§āϰāĻžāωāϜāĻžāϰāϗ⧁āϞāĻŋāϕ⧇ āϞāĻ•ā§āĻˇā§āϝ āĻ•āϰ⧇ āĻĨāĻžāϕ⧇āύ (āϝāĻž āĻĒā§āϰāϤāĻŋāϟāĻŋ āĻĒā§āϰāϧāĻžāύ āĻŦā§āϰāĻžāωāϜāĻžāϰ⧇āϰ āϏāĻ°ā§āĻŦāĻļ⧇āώ āϏāĻ‚āĻ¸ā§āĻ•āϰāĻŖ āĻ…āĻ¨ā§āϤāĻ°ā§āϭ⧁āĻ•ā§āϤ āĻ•āϰ⧇) āφāĻĒāύāĻŋ āĻĒāϞāĻŋāĻĢāĻŋāϞ āĻ…ā§āϝāĻžāϏāĻŋāĻ™ā§āĻ• āĻĢāĻžāĻ‚āĻļāύāϗ⧁āϞāĻŋ āϏāĻžāϜāĻžāϤ⧇ āĻĒāĻžāϰ⧇āύ⧎

Babel āφāĻĒāύāĻžāϰ āϜāĻ¨ā§āϝ āĻāϟāĻŋ āĻ•āϰāĻŦ⧇, āĻāĻ–āĻžāύ⧇ Babel REPL āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āĻāĻ•āϟāĻŋ āωāĻĻāĻžāĻšāϰāĻŖ āϰāϝāĻŧ⧇āϛ⧇⧎

āφāĻŽāĻŋ āĻŸā§āϰāĻžāĻ¨ā§āϏāĻĒāĻŋāϞāĻŋāĻ‚ āĻĒāĻĻā§āϧāϤāĻŋāϰ āĻĒāϰāĻžāĻŽāĻ°ā§āĻļ āĻĻāĻŋāĻšā§āĻ›āĻŋ, āĻ•āĻžāϰāĻŖ āφāĻĒāύāĻžāϰ āϟāĻžāĻ°ā§āϗ⧇āϟ āĻŦā§āϰāĻžāωāϜāĻžāϰāϗ⧁āϞāĻŋ āĻ…ā§āϝāĻžāϏāĻŋāĻ™ā§āĻ• āĻĢāĻžāĻ‚āĻļāύ āϏāĻŽāĻ°ā§āĻĨāύ āĻ•āϰāϞ⧇ āφāĻĒāύāĻŋ āĻāϟāĻŋ āĻŦāĻ¨ā§āϧ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āύ, āĻ•āĻŋāĻ¨ā§āϤ⧁ āφāĻĒāύāĻŋ āϝāĻĻāĻŋ āϏāĻ¤ā§āϝāĻŋāχ āĻāĻ•āϟāĻŋ āĻŸā§āϰāĻžāĻ¨ā§āϏāĻĒāĻŋāϞāĻžāϰ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāϤ⧇ āύāĻž āϚāĻžāύ āϤāĻŦ⧇ āφāĻĒāύāĻŋ āĻŦā§āϝāĻžāĻŦ⧇āϞ⧇āϰ āĻĒāϞāĻŋāĻĢāĻŋāϞ āύāĻŋāϤ⧇ āĻĒāĻžāϰ⧇āύ āĻāĻŦāĻ‚ āĻāϟāĻŋ āύāĻŋāĻœā§‡ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āύāĨ¤ āĻāϰ āĻĒāϰāĻŋāĻŦāĻ°ā§āϤ⧇:

async function slowEcho(val) {
  await wait(1000);
  return val;
}

â€ĻāφāĻĒāύāĻŋ āĻĒāϞāĻŋāĻĢāĻŋāϞ āĻ…āĻ¨ā§āϤāĻ°ā§āϭ⧁āĻ•ā§āϤ āĻ•āϰāĻŦ⧇āύ āĻāĻŦāĻ‚ āϞāĻŋāĻ–āĻŦ⧇āύ:

const slowEcho = createAsyncFunction(function* (val) {
  yield wait(1000);
  return val;
});

āĻŽāύ⧇ āϰāĻžāĻ–āĻŦ⧇āύ āϝ⧇ āφāĻĒāύāĻžāϕ⧇ createAsyncFunction āĻ•āϰāϤ⧇ āĻāĻ•āϟāĻŋ āĻœā§‡āύāĻžāϰ⧇āϟāϰ ( function* ) āĻĒāĻžāϏ āĻ•āϰāϤ⧇ āĻšāĻŦ⧇ āĻāĻŦāĻ‚ await āĻĒāϰāĻŋāĻŦāĻ°ā§āϤ⧇ yield āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāϤ⧇ āĻšāĻŦ⧇āĨ¤ āϤāĻž āĻ›āĻžāĻĄāĻŧāĻž āĻāϟāĻŋ āĻāĻ•āχ āĻ•āĻžāϜ āĻ•āϰ⧇āĨ¤

āĻ“āϝāĻŧāĻžāĻ°ā§āĻ•āĻ…ā§āϝāĻžāϰāĻžāωāĻ¨ā§āĻĄ: āĻĒ⧁āύāĻ°ā§āϜāĻ¨ā§āĻŽāĻ•āĻžāϰ⧀

āφāĻĒāύāĻŋ āϝāĻĻāĻŋ āĻĒ⧁āϰāĻžāύ⧋ āĻŦā§āϰāĻžāωāϜāĻžāϰāϗ⧁āϞāĻŋāϕ⧇ āϟāĻžāĻ°ā§āϗ⧇āϟ āĻ•āϰ⧇āύ, āϤāĻŦ⧇ āĻŦā§āϝāĻžāĻŦ⧇āϞ āĻœā§‡āύāĻžāϰ⧇āϟāϰāϗ⧁āϞāĻŋāϕ⧇ āĻŸā§āϰāĻžāĻ¨ā§āϏāĻĒāĻŋāϞ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇, āϝāĻž āφāĻĒāύāĻžāϕ⧇ IE8 āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āĻ…ā§āϝāĻžāϏāĻŋāĻ™ā§āĻ• āĻĢāĻžāĻ‚āĻļāύāϗ⧁āϞāĻŋ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻžāϰ āĻ…āύ⧁āĻŽāϤāĻŋ āĻĻ⧇āϝāĻŧāĨ¤ āĻāϟāĻŋ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āφāĻĒāύāĻžāϰ āĻĒā§āϰāϝāĻŧā§‹āϜāύ Babel āĻāϰ es2017 āĻĒā§āϰāĻŋāϏ⧇āϟ āĻāĻŦāĻ‚ es2015 āĻĒā§āϰāĻŋāϏ⧇āϟ āĨ¤

āφāωāϟāĻĒ⧁āϟ āϤāϤāϟāĻž āϏ⧁āĻ¨ā§āĻĻāϰ āύāϝāĻŧ , āϤāĻžāχ āϕ⧋āĻĄ-āĻŦā§āϞ⧋āĻŸā§‡āϰ āϜāĻ¨ā§āϝ āϏāϤāĻ°ā§āĻ• āĻĨāĻžāϕ⧁āύāĨ¤

āϏāĻŦ āϜāĻŋāύāĻŋāϏ āĻ…ā§āϝāĻžāϏāĻŋāĻ™ā§āĻ•!

āϏāĻŽāĻ¸ā§āϤ āĻŦā§āϰāĻžāωāϜāĻžāϰ āϜ⧁āĻĄāĻŧ⧇ async āĻĢāĻžāĻ‚āĻļāύ āĻ˛ā§āϝāĻžāĻ¨ā§āĻĄ āĻ•āϰāĻžāϰ āĻĒāϰ⧇, āĻĒā§āϰāϤāĻŋāϟāĻŋ āĻĒā§āϰāϤāĻŋāĻļā§āϰ⧁āϤāĻŋ-āϰāĻŋāϟāĻžāĻ°ā§āύāĻŋāĻ‚ āĻĢāĻžāĻ‚āĻļāύ⧇ āϏ⧇āϗ⧁āϞāĻŋ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧁āύ! āϤāĻžāϰāĻž āĻļ⧁āϧ⧁āĻŽāĻžāĻ¤ā§āϰ āφāĻĒāύāĻžāϰ āϕ⧋āĻĄ āĻĒāϰāĻŋāĻĒāĻžāϟāĻŋ āĻ•āϰ⧇ āύāĻž, āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻāϟāĻŋ āύāĻŋāĻļā§āϚāĻŋāϤ āĻ•āϰ⧇ āϝ⧇ āĻĢāĻžāĻ‚āĻļāύ āϏāĻ°ā§āĻŦāĻĻāĻž āĻāĻ•āϟāĻŋ āĻĒā§āϰāϤāĻŋāĻļā§āϰ⧁āϤāĻŋ āĻĒā§āϰāĻĻāĻžāύ āĻ•āϰāĻŦ⧇āĨ¤

āφāĻŽāĻŋ 2014 āϏāĻžāϞ⧇ āĻ…ā§āϝāĻžāϏāĻŋāĻ™ā§āĻ• āĻĢāĻžāĻ‚āĻļāύ āϏāĻŽā§āĻĒāĻ°ā§āϕ⧇ āϏāĻ¤ā§āϝāĻŋāχ āωāĻ¤ā§āϤ⧇āϜāĻŋāϤ āĻšāϝāĻŧ⧇āĻ›āĻŋāϞāĻžāĻŽ, āĻāĻŦāĻ‚ āĻŦā§āϰāĻžāωāϜāĻžāϰ⧇ āĻŦāĻžāĻ¸ā§āϤāĻŦ⧇ āϤāĻžāĻĻ⧇āϰ āĻ˛ā§āϝāĻžāĻ¨ā§āĻĄ āĻ•āϰāϤ⧇ āĻĻ⧇āϖ⧇ āϖ⧁āĻŦ āĻ­āĻžāϞ⧋ āϞāĻžāĻ—āϛ⧇āĨ¤ āωāĻĢ!