re:re:actable
Урок 063 минуты чтения

Задача: последовательное выполнение промисов

На этой странице
Кратко

Иногда задачи нужно выполнить строго по очереди: следующая начинается только после завершения предыдущей (миграции, зависимые запросы, анимации шагов, сохранение в порядке изменений). Решения: цикл for...of с await, цепочка через reduce с .then или очередь промисов, в которую задачи добавляются в любой момент. Частая ловушка — forEach(async ...): он не ждет промисы и запускает всё параллельно.

Вопрос

Выполните массив асинхронных функций последовательно и верните массив результатов. Почему forEach с async не работает? Как сделать очередь, в которую можно добавлять задачи позже?

Решение 1: for...of + await

async function runSequentially(tasks) {
  const results = [];
  for (const task of tasks) {
    results.push(await task());     // следующая начнется после завершения текущей
  }
  return results;
}

Решение 2: reduce

function runSequentiallyReduce(tasks) {
  return tasks.reduce(
    (chain, task) => chain.then((results) => task().then((value) => [...results, value])),
    Promise.resolve([]),
  );
}

Ловушка forEach

const ids = [1, 2, 3];
 
ids.forEach(async (id) => {
  await save(id);          // forEach не ждет: все save стартуют сразу
});
console.log("готово");     // выведется до завершения сохранений

forEach игнорирует возвращаемые промисы. Используйте for...of (последовательно) или Promise.all(ids.map(...)) (параллельно).

Сравнение

const tasks = [() => delay(300, "a"), () => delay(200, "b"), () => delay(100, "c")];
 
await runSequentially(tasks);                 // ~600 мс, ["a", "b", "c"]
await Promise.all(tasks.map((t) => t()));     // ~300 мс, ["a", "b", "c"]

Очередь задач

function createQueue() {
  let tail = Promise.resolve();
 
  return function enqueue(task) {
    const result = tail.then(() => task());
    tail = result.catch(() => {});      // ошибка одной задачи не ломает очередь
    return result;                      // вызывающий получает результат своей задачи
  };
}
 
const enqueue = createQueue();
 
enqueue(() => delay(300, "first")).then(console.log);
enqueue(() => delay(100, "second")).then(console.log);
// "first" через 300 мс, затем "second" через еще 100 мс

Применение: последовательное сохранение черновика, чтобы старый запрос не перезаписал новый; работа с ресурсом, который не допускает параллельного доступа.

Доп. вопросы интервьюера

  • Когда последовательно, а когда параллельно? последовательно — если задачи зависят друг от друга или нельзя нагружать сервер; иначе параллельно (или пул).
  • Как остановиться на первой ошибке? в for...of ошибка await сама прервет цикл; для продолжения — try/catch внутри.
  • Как передать результат предыдущей задачи в следующую? reduce с аккумулятором-значением: chain.then((prev) => task(prev)).
  • Асинхронный генератор? for await (const item of source) обрабатывает поток данных последовательно.

Что важно помнить

  • forEach, map, filter не ждут асинхронные колбэки.
  • for...of + await — самый читаемый способ последовательного выполнения.
  • В очереди «проглатывайте» ошибку в хвосте цепочки, иначе одна ошибка остановит все последующие задачи.
  • Связанные задачи: ограничение параллельности.

Мини-шпаргалка

Последовательно: for (const t of tasks) results.push(await t()) или reduce с .then. forEach(async) — не ждет. Очередь: tail = tail.then(task), tail = result.catch(() => {}). Параллельно — Promise.all, с лимитом — пул.

Документация

MDN: for...of, MDN: async function, MDN: for await...of.

Дочитали до конца?
Отметьте урок — прогресс сохранится в браузере.

Поиск

Поиск по урокам