Promise.all, race, any и allSettled

Здесь будет встроен видео-разбор темы (5–7 минут, YouTube / RuTube / VK Видео) — тем, кто лучше воспринимает на слух, текст ниже не обязателен.

Промис начинает работу тогда, когда его создали, а не тогда, когда его начали ждать. Если написать два await подряд, вторая задача честно постоит в очереди — и вы прождёте сумму двух ожиданий вместо большего из них.

Проверим: обе «задачи» рапортуют о старте сразу, ещё до того, как кто-то подписался на результат.

js

const wait = (ms, value) => new Promise((resolve) => {
  console.log("старт:", value);
  setTimeout(() => resolve(value), ms);
});

wait(300, "чай");
wait(100, "кофе");

Сначала предположите, что выведет код

Отсюда приём: сначала создаём все промисы, потом ждём их вместе. Разбирать пачку вручную неудобно — для этого есть комбинаторы, которые берут массив промисов и возвращают один общий.

Promise.all дожидается всех и отдаёт массив результатов. Порядок в нём — как в исходном массиве, а не как по скорости: медленный элемент останется на своём месте.

js

const wait = (ms, value) => new Promise((r) => setTimeout(() => r(value), ms));

Promise.all([wait(300, "чай"), wait(100, "кофе")]).then((list) => {
  console.log(list);
});

Сначала предположите, что выведет код

Теперь плохая новость. Если хотя бы один промис отклонён, общий промис отклоняется в ту же секунду — с этой самой ошибкой, не дожидаясь остальных. Результаты тех, кто успел, просто пропадают: до них уже не добраться.

js

const ok = (v) => Promise.resolve(v);
const bad = (m) => Promise.reject(new Error(m));

Promise.all([ok(1), bad("нет сети"), ok(3)])
  .then((list) => console.log("успех", list))
  .catch((err) => console.log("упало:", err.message));

Сначала предположите, что выведет код

all — командный зачёт: споткнулся один, не зачли всем.

Когда каждый ответ ценен сам по себе — рассылаем десять писем, сохраняем пять файлов — терять всё из-за одного невезучего глупо. Promise.allSettled дожидается всех и не отклоняется никогда.

Вместо голых значений в массиве лежат отчёты: у успешных — status: "fulfilled" и value, у провалившихся — status: "rejected" и reason.

js

const ok = (v) => Promise.resolve(v);
const bad = (m) => Promise.reject(new Error(m));

Promise.allSettled([ok(1), bad("нет сети")]).then((list) => {
  console.log(list[0]);
  console.log(list[1].status, list[1].reason.message);
});

Сначала предположите, что выведет код

Ошибку тут не поймать через catch — её надо искать в результатах. Это скорее плюс: язык заставляет вас решить, что делать с каждым провалом, а не заметать их под общий catch.

Promise.race — гонка без правил: побеждает тот, кто завершился первым, и неважно, успехом или ошибкой. Остальные продолжают работать, но их исход уже никого не интересует.

js

const wait = (ms, v) => new Promise((r) => setTimeout(() => r(v), ms));
const fail = (ms, m) => new Promise((_, rej) => setTimeout(() => rej(new Error(m)), ms));

Promise.race([fail(50, "сеть отвалилась"), wait(200, "поздний успех")])
  .then((v) => console.log("ок", v))
  .catch((e) => console.log("race поймал:", e.message));

Сначала предположите, что выведет код

Отсюда главный практический рецепт — таймаут. Ставим в одну гонку настоящую задачу и промис, который через N миллисекунд обязательно отклонится.

js

const wait = (ms, v) => new Promise((r) => setTimeout(() => r(v), ms));
const timeout = (ms) => new Promise((_, rej) => setTimeout(() => rej(new Error("таймаут")), ms));

Promise.race([wait(1000, "ответ сервера"), timeout(200)])
  .then((v) => console.log(v))
  .catch((e) => console.log(e.message));

Сначала предположите, что выведет код

Комбинаторы ничего не отменяют. Проигравший запрос продолжит идти по сети, сервер честно его обработает, а результат просто никому не отдадут. Для тяжёлой выгрузки это заметная трата.

Настоящая отмена — отдельная механика: AbortController и его signal, который понимает fetch. Гонка решает, «сколько мы готовы ждать», а контроллер — «когда пора прекратить работу».

Promise.any тоже возвращает финиш первого, но ошибку финишем не считает: он ждёт первый успех и молча пропускает провалы по дороге. Классический сценарий — несколько зеркал одного файла.

js

const bad = (m) => Promise.reject(new Error(m));
const wait = (ms, v) => new Promise((r) => setTimeout(() => r(v), ms));

Promise.any([bad("зеркало 1 упало"), wait(50, "зеркало 2 ответило")])
  .then((v) => console.log(v));

Сначала предположите, что выведет код

Если провалились все до единого, any отклоняется особой ошибкой — AggregateError. В её свойстве errors лежит массив всех причин, в порядке исходного массива.

js

const bad = (m) => Promise.reject(new Error(m));

Promise.any([bad("а"), bad("б")]).catch((err) => {
  console.log(err.name);
  console.log(err.errors.map((e) => e.message));
});

Сначала предположите, что выведет код

Все четыре различаются двумя вопросами: чего они дожидаются и что считают поводом упасть.

Метод	Ждёт	Что отдаёт	Когда отклоняется
Promise.all	всех	массив значений в исходном порядке	на первой же ошибке
Promise.allSettled	всех	массив отчётов status + value/reason	никогда
Promise.race	первого завершившегося	его значение или ошибку	если первым пришёл провал
Promise.any	первого успешного	его значение	только если упали все — AggregateError

На практике: профиль и настройки для страницы — all (без любого из них рисовать нечего). Рассылка уведомлений — allSettled и отчёт «8 из 10». Ограничение ожидания — race с таймером. Несколько равноценных источников — any.

Все четыре принимают любой перебираемый объект, а не только массив, и молча оборачивают обычные значения: Promise.all([1, Promise.resolve(2)]) даст [1, 2].

Отдельная история — пустой массив. Три метода отвечают мгновенно, а race зависает навсегда: гонка без участников не может закончиться.

js

Promise.all([]).then((v) => console.log("all", v));
Promise.allSettled([]).then((v) => console.log("settled", v));
Promise.any([]).catch((e) => console.log(e.name));
// Promise.race([]) не завершится никогда

Сначала предположите, что выведет код

Промис стартует в момент создания: создайте всю пачку сразу, а ждать её отдайте комбинатору.
Promise.all возвращает массив значений в порядке аргументов, но первая же ошибка отклоняет весь набор.
Promise.allSettled не отклоняется никогда: у каждого элемента есть status и либо value, либо reason.
Promise.race отдаёт первый завершившийся исход — успех или ошибку; на этом строится таймаут.
Promise.any ждёт первый успех, а если провалились все — бросает AggregateError с массивом errors.

1/3В Promise.all([ok(1), bad(), ok(3)]) второй промис отклонён. Что произойдёт?

2/3Все промисы, переданные в Promise.any, отклонились. Что придёт в catch?

3/3В Promise.race первым через 50 мс завершился промис с ошибкой, а через 200 мс второй — успешно. Что увидим?

Таймаут для любого промиса

Напишите функцию withTimeout(promise, ms): она возвращает промис, который ведёт себя как исходный, но если тот не уложился в ms миллисекунд — отклоняется ошибкой с текстом «таймаут».

js

const wait = (ms, v) => new Promise((r) => setTimeout(() => r(v), ms));
const withTimeout = (promise, ms) => promise; // заменить на свою реализацию

withTimeout(wait(50, "успел"), 200).then((v) => console.log(v)); // это уже работает
withTimeout(wait(500, "не успел"), 200).catch((e) => console.log(e.message));
// сейчас ничего, должно быть: таймаут

Сначала предположите, что выведет код

Задача — гонка между делом и будильником: кто первый, тот и определяет исход.

jsлистинг · не запускается

const withTimeout = (promise, ms) =>
  Promise.race([
    promise,
    new Promise((_, reject) => setTimeout(() => reject(new Error("таймаут")), ms)),
  ]);

const withTimeout = (promise, ms) =>
  Promise.race([
    promise,
    new Promise((_, reject) => setTimeout(() => reject(new Error("таймаут")), ms)),
  ]);

Успел исходный промис — race отдаст его значение, а будильник прозвонит в пустоту. Не успел — победит отклонение таймера. Помните: сама задача при этом не отменяется и продолжит выполняться в фоне; чтобы действительно прервать запрос, нужен AbortController.

Сколько писем дошло

Реализуйте countOk(list) — она принимает массив промисов и возвращает промис с числом успешно выполненных. Падать из-за неудачных нельзя: считаем всех.

js

const ok = (v) => Promise.resolve(v);
const bad = (m) => Promise.reject(new Error(m));
const letters = [ok("a"), bad("адрес не найден"), ok("c")];

const countOk = async (list) => 0; // заменить на подсчёт успешных
countOk(letters).then((n) => console.log(n)); // сейчас 0, должно быть 2

Сначала предположите, что выведет код

Раз падать нельзя — только allSettled, а дальше обычный подсчёт по полю status.

jsлистинг · не запускается

const countOk = async (list) => {
  const results = await Promise.allSettled(list);
  return results.filter((r) => r.status === "fulfilled").length;
};

const countOk = async (list) => {
  const results = await Promise.allSettled(list);
  return results.filter((r) => r.status === "fulfilled").length;
};

Заодно из results легко достать и причины неудач: results.filter((r) => r.status === "rejected").map((r) => r.reason.message) — получится готовый список адресов, по которым письмо не ушло.

Promise.all, race, any и allSettled

Видеоразбор темы за 5–7 минут

Ждать по очереди — дорогопромис стартует в момент создания

Promise.allвсе результаты или первая ошибка

Promise.allSettledкогда важен каждый исход отдельно

Promise.raceпервый финишировавший, любой ценой

Promise.anyпервый, кто вообще справился

Как выбратьчетыре метода на одной таблице

Итогошпаргалка по теме

Проверьте себятри быстрых вопроса

Задачидве задачи с решениями

Таймаут для любого промиса

Сколько писем дошло