Використання мікрозадач у JavaScript за допомогою queueMicrotask()

Мікрозадача - це коротка функція, яка виконується після того, як функція чи програма, яка її створила, завершується, та тільки якщо стек виконання JavaScript порожній, але перед поверненням контролю до циклу подій користувацького агента для керування середовищем виконання скрипта. Даний цикл подій може бути або головним циклом подій веб-переглядача, або циклом подій, що керує веб-виконавцем. Це дозволяє даній функції виконуватись без ризику втрутитись у виконання іншого скрипта, в той же час гарантує, що мікрозадача виконається до того, як користувацький агент матиме змогу відреагувати на дії, виконані цією мікрозадачею.

Проміси JavaScript та Mutation Observer API використовують чергу мікрозадач для виконання своїх зворотніх викликів, але бувають інші випадки, коли здатність відкласти роботу до завершення поточного проходу циклу подій може бути корисна. Щоб дозволити стороннім бібліотекам, фреймворкам та поліфілам використовувати мікрозадачі, метод queueMicrotask() доступний у інтерфейсах Window та Worker через домішку WindowOrWorkerGlobalScope.

Задачі та мікрозадачі

Щоб належно обговорювати мікрозадачі, насамперед, корисно знати, що таке задача JavaScript та чим мікрозадачі відрізняються від задач. Це швидке, спрощене пояснення, але якщо вам потрібно більше подробиць, ви можете їх дізнатись у статті В подробицях: мікрозадачі та середовище виконання JavaScript.

Задачі

Задача - це будь-який код JavaScript, що запланований до запуску стандартними механізмами, такими як початковий запуск програми, запуск зворотного виклику для події, або запуск таймера чи інтервалу. Всі вони розташовуються у черзі задач.

Задачі додаються до черги задач, коли:

  • Безпосередньо виконується нова програма чи підпрограма JavaScript (наприклад, з консолі чи запуском коду у елементі <script>).
  • Спрацьовує подія, додаючи функцію зворотного виклику події до черги задач.
  • Доходить черга таймера чи інтервалу, створеного методом setTimeout() чи setInterval(), що спричиняє додавання відповідного зворотного виклику до черги задач.

Цикл подій, що керує вашим кодом, обробляє ці задачі одна за одною, в тому порядку, в якому вони були додані у чергу. Лише ті задачі, які вже знаходились у черзі задач, коли почався прохід циклу подій, будуть виконані протягом поточної ітерації. Решті доведеться зачекати наступної ітерації.

Мікрозадачі

Спершу різниця між мікрозадачами та задачами здається незначною. І вони дійсно схожі; і те, й інше - код JavaScript, який розміщується у черзі та запускається у належний час. Однак, в той час, як цикл подій запускає лише задачі, наявні у черзі на момент початку ітерації, одна за одною, з мікрозадачами він поводиться зовсім по-іншому.

Є дві ключові відмінності.

По-перше, кожен раз, коли задача завершується, цикл подій перевіряє, чи задача повертає контроль іншому коду JavaScript. Якщо ні, він запускає всі мікрозадачі з черги мікрозадач. Таким чином, черга мікрозадач обробляється багаторазово протягом однієї ітерації циклу подій, в тому числі після обробки подій та інших зворотних викликів.

По-друге, якщо мікрозадача додає інші мікрозадачі до черги, викликаючи метод queueMicrotask(), ці додані мікрозадачі виконуються перед запуском наступної задачі. Все тому, що цикл подій викликатиме мікрозадачі, доки у черзі не залишиться жодної, навіть якщо при цьому додаються нові.

Застереження: Оскільки мікрозадачі можуть ставити у чергу інші мікрозадачі, а цикл подій продовжуватиме обробляти мікрозадачі, доки черга не спорожніє, існує реальний ризик спричинити нескінченну обробку мікрозадач циклом подій. Будьте обережні, додаючи мікрозадачі рекурсивно.

Використання мікрозадач

Перед тим, як продовжити, важливо зазначити ще раз, що більшість програмістів нечасто використовують мікрозадачі, якщо взагалі використовують. Це вузькоспеціалізована функціональність сучасної JavaScript-розробки для переглядачів, що дозволяє вам запланувати виконання коду попереду чогось іншого у довгому списку речей, що чекають на виконання комп'ютером користувача. Зловживання цією можливістю призведе до проблем з продуктивністю.

Додавання мікрозадач у чергу

Таким чином, вам варто використовувати мікрозадачі лише тоді, коли немає іншого рішення, або при створенні фреймворків чи бібліотек, які мають використовувати мікрозадачі для створення функціональності, яку реалізують. Хоча раніше існували трюки, які дозволяли ставити мікрозадачі в чергу (наприклад, створення проміса, який негайно вирішується), введення методу queueMicrotask() додає стандартний спосіб створення мікрозадач безпечно та без допомоги трюків.

Введення методу queueMicrotask() дозволяє уникнути вивертів, що трапляються під час такого проникнення у чергу мікрозадач за допомогою промісів. Наприклад, при використанні промісів для створення мікрозадач, винятки, викинуті зворотним викликом, повідомляються як відхилені проміси, а не як стандартні винятки. Також, створення та знищення промісів потребує додаткових витрат як часу, так і пам'яті, цього уникає функція, яка належним чином ставить мікрозадачі у чергу.

Просто передайте функцію JavaScript, яку треба викликати, коли контекст обробляє мікрозадачі, у метод queueMicrotask(), доступний у глобальному контексті, як визначено у інтерфейсі Window або Worker, в залежності від поточного контексту виконання.

queueMicrotask(() => {
  /* тут код, який виконує мікрозадача */
});

Сама функція мікрозадачі не приймає параметрів та не повертає значення.

Коли використовувати мікрозадачі

У цьому розділі ми розглянемо сценарії, в яких мікрозадачі є особливо корисними. Загалом, мова йде про отримання та перевірку результатів, або прибирання, після того, як головне тіло контексту виконання JavaScript завершується, але перед тим, як опрацьовуються будь-які обробники подій, таймери та інтервали, чи інші зворотні виклики.

Коли це корисно?

Головна причина використання мікрозадач проста: забезпечити послідовний порядок виконання задач, навіть коли результати чи дані доступні синхронно, одночасно знижуючи ризик помітних користувачу затримок у операціях.

Забезпечення порядку виконання при використанні промісів в умовних конструкціях

Одна з ситуацій, в якій можуть використовуватись мікрозадачі - це забезпечення завжди послідовного порядку виконання у ситуації, коли проміси використовуються у одному блоці конструкції if...else (чи іншої умовної конструкції), але не в іншому блоці. Розглянемо наступний код:

customElement.prototype.getData = url => {
  if (this.cache[url]) {
    this.data = this.cache[url];
    this.dispatchEvent(new Event("load"));
  } else {
    fetch(url).then(result => result.arrayBuffer()).then(data => {
      this.cache[url] = data;
      this.data = data;
      this.dispatchEvent(new Event("load"));
    });
  }
};

Проблема тут полягає в тому, що, використовуючи задачу в одній гілці конструкції if...else (у випадку, коли зображення доступне з кешу), але маючи проміси у блоці else, ми отримуємо ситуацію, в якій порядок операцій може бути різним; наприклад, як показано нижче.

element.addEventListener("load", () => console.log("Завантажені дані"));
console.log("Отримання даних...");
element.getData();
console.log("Дані отримано");

Виконання цього коду два рази підряд дає результати, наведені у таблиці:

Результати, коли дані не кешовані (зліва) та коли дані знайдені в кеші
Дані не кешовані Дані кешовані
Отримання даних
Дані отримано
Завантажені дані
Отримання даних
Завантажені дані
Дані отримано

Навіть гірше, іноді властивість елементів data буде встановлена, а іноді не буде, на той момент, коли цей код завершує виконання.

Ми можемо забезпечити послідовний порядок цих операцій використанням мікрозадачі у блоці if, щоб збалансувати два блоки:

customElement.prototype.getData = url => {
  if (this.cache[url]) {
    queueMicrotask(() => {
      this.data = this.cache[url];
      this.dispatchEvent(new Event("load"));
    });
  } else {
    fetch(url).then(result => result.arrayBuffer()).then(data => {
      this.cache[url] = data;
      this.data = data;
      this.dispatchEvent(new Event("load"));
    });
  }
};

Це збалансовує два блоки, бо тепер в обох ситуаціях встановлення значення data та запуск події load відбувається всередині мікрозадачі (за допомогою queueMicrotask() у блоці if та за допомогою промісів, що використовуються методом fetch(), у блоці else).

Пакетне виконання операцій

Ви також можете використати мікрозадачі, щоб зібрати множину запитів з різних джерел у єдиний пакет, уникаючи можливих затрат, пов'язаних з багатьма викликами задля виконання задач одного типу.

Фрагмент коду, наведений нижче, створює функцію, яка збирає множину повідомлень у масив, використовуючи мікрозадачу, щоб відправити їх як єдиний об'єкт по завершенні контексту.

const messageQueue = [];

let sendMessage = message => {
  messageQueue.push(message);

  if (messageQueue.length === 1) {
    queueMicrotask(() => {
      const json = JSON.stringify(messageQueue);
      messageQueue.length = 0;
      fetch("url-of-receiver", json);
    });
  }
};

Коли викликається sendMessage(), вказане повідомлення спочатку додається у масив черги повідомлень. А далі відбувається цікаве.

Якщо повідомлення, яке ми додали до масиву, є першим, ми додаємо мікрозадачу, яка відправлятиме пакет. Мікрозадача виконається, як завжди, коли шлях виконання JavaScript сягне верхнього рівня, одразу перед зворотними викликами. Це означає, що будь-які подальші виклики sendMessage(), зроблені в цей час, додадуть свої повідомлення до черги повідомлень, але, завдяки перевірці довжини масиву перед додаванням мікрозадачі, нових мікрозадач у чергу не буде додано.

Коли запускається мікрозадача, то вона має масив, потенційно, багатьох повідомлень, які на неї очікують. Вона починається кодуванням його як JSON за допомогою методу JSON.stringify(). Після цього вміст масиву більше не потрібний, а отже, ми спорожнюємо масив messageQueue. Нарешті, ми використовуємо метод fetch(), щоб відправити рядок JSON на сервер.

Це дозволяє кожному виклику sendMessage(), зробленому під час тієї самої ітерації циклу подій, додавати свої повідомлення до тієї самої операції fetch(), без потенційних затримок трансмісії іншими задачами, такими як таймери та подібні.

Сервер отримає рядок JSON, далі, ймовірно, декодує його та обробить повідомлення, які знайде у отриманому масиві.

Приклади

Простий приклад мікрозадачі

У цьому простому прикладі ми бачимо, що додавання мікрозадачі у чергу спричиняє запуск зворотного виклику мікрозадачі після того, як тіло цього скрипта верхнього рівня завершує виконання.

JavaScript

У наступному коді ми бачимо виклик queueMicrotask(), що використовується для планування запуску мікрозадачі. Цей виклик оточують виклики log(), користувацької функції, яка просто виводить текст на екран.

log("До розміщення мікрозадачі в черзі");
queueMicrotask(() => {
  log("Мікрозадача запустилась.")
});
log("Після розміщення мікрозадачі в черзі");

Результат

Таймер та приклад мікрозадачі

У цьому прикладі встановлюється таймер для запуску через нуль мілісекунд (або "якомога швидше"). Це демонструє різницю між тим, що означає "якомога швидше" при плануванні нової задачі (наприклад, при використанні setTimeout()) у порівнянні з використанням мікрозадачі.

JavaScript

У наступному коді ми бачимо виклик queueMicrotask(), який використовується для планування запуску мікрозадачі. Цей виклик розташований між викликами log(), користувацької функції, яка просто виводить текст на екран.

Наступний код встановлює таймер, який має запуститися через нуль мілісекунд, після чого додає у чергу мікрозадачу. Він оточений викликами log() для виводу додаткових повідомлень.

let callback = () => log("Запустився звичайний зворотний виклик таймера");

let urgentCallback = () => log("*** О, ні! Запустився терміновий зворотний виклик!");

log("Початок головної програми");
setTimeout(callback, 0);
queueMicrotask(urgentCallback);
log("Кінець головної програми");

Результат

Зауважте, що текст, який виводиться головною програмою, з'являється першим, далі текст, виведений мікрозадачею, а за ним текст зворотного виклику таймера. Все тому, що, коли задача, що керує виконанням головної програми, завершується, черга мікрозадач обробляється раніше черги задач, в якій розташований зворотний виклик таймера. Знання того, що задачі та мікрозадачі розташовуються у різних чергах, і те, що мікрозадачі виконуються першими, допомагає легше в цьому розібратись.

Мікрозадача з функції

Цей приклад трохи розширює попередній додаванням функції, яка виконує певну роботу. Ця функція використовує queueMicrotask(), щоб додати мікрозадачу. Важливий момент, який варто з нього винести - мікрозадача не виконується, коли завершується функція, а тільки коли завершується головна програма.

JavaScript

Код головної програми наступний. Функція doWork() викликає queueMicrotask(), але мікрозадача не запускається, доки вся програма не завершується, оскільки саме тоді завершується задача і не залишається нічого іншого у стеку виконання.

let callback = () => log("Запустився звичайний зворотний виклик таймера");

let urgentCallback = () => log("*** О, ні! Запустився терміновий зворотний виклик!");

let doWork = () => {
  let result = 1;
 
  queueMicrotask(urgentCallback);

  for (let i=2; i<=10; i++) {
    result *= i;
  }
  return result;
};

log("Початок головної програми");
setTimeout(callback, 0);
log(`10! дорівнює ${doWork()}`);
log("Кінець головної програми");

Результат

Див. також