Какое свойство дожидается выполнения всех Promise?

Метод Promise.all() для ожидания всех Promise

В JavaScript, чтобы дождаться выполнения всех Promise параллельно и получить их результаты, используется статический метод Promise.all(). Это один из ключевых инструментов для работы с асинхронными операциями, особенно когда необходимо выполнить несколько независимых задач одновременно и обработать их совокупный результат.

Как работает Promise.all()

Метод принимает итерируемую коллекцию (обычно массив) из Promise-объектов и возвращает новый Promise. Этот новый Promise:

1. Исполняется (fulfilled), когда все переданные Promise успешно завершаются.
2. Отклоняется (rejected), если хотя бы один из Promise завершается с ошибкой.

Результатом исполненного Promise будет массив значений в том же порядке, в котором Promise были переданы в Promise.all(). Это гарантирует соответствие результатов исходным Promise, даже если время их выполнения различается.

Пример использования

const promise1 = fetch('https://api.example.com/data1');
const promise2 = fetch('https://api.example.com/data2');
const promise3 = fetch('https://api.example.com/data3');

Promise.all([promise1, promise2, promise3])
  .then((responses) => {
    // responses - массив результатов всех трёх fetch-запросов
    return Promise.all(responses.map(response => response.json()));
  })
  .then((data) => {
    console.log('Все данные получены:', data);
  })
  .catch((error) => {
    console.error('Ошибка в одном из запросов:', error);
  });

В этом примере:

• Три асинхронных HTTP-запроса выполняются параллельно.
• Promise.all() ждёт завершения всех трёх запросов.
• Если все успешны — обрабатываются результаты.
• Если любой запрос завершится ошибкой — сработает блок catch.

Ключевые особенности Promise.all()

• Параллельное выполнение: Все Promise запускаются одновременно, а не последовательно.
• «Быстрая» ошибка (fail-fast): При первой же ошибке в любом из Promise весь Promise.all() немедленно завершается с этой ошибкой, игнорируя остальные ещё не завершённые Promise.
• Сохранение порядка: Порядок результатов в массиве соответствует порядку исходных Promise, независимо от времени их выполнения.
• Неизменяемость: Не изменяет исходные Promise-объекты.

Альтернативные методы для разных сценариев

Иногда Promise.all() не подходит, и нужны другие методы:

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

Promise.allSettled([promise1, promise2, promise3])
  .then((results) => {
    results.forEach((result) => {
      if (result.status === 'fulfilled') {
        console.log('Успех:', result.value);
      } else {
        console.log('Ошибка:', result.reason);
      }
    });
  });

• Promise.race() — возвращает результат первого завершённого Promise (успешного или ошибочного). Используется для таймаутов или когда важен первый ответ.

const timeout = new Promise((_, reject) => 
  setTimeout(() => reject(new Error('Таймаут')), 5000)
);

Promise.race([fetch('https://api.example.com/data'), timeout])
  .then((response) => console.log('Данные получены вовремя'))
  .catch((error) => console.error('Ошибка или таймаут:', error));

• Promise.any() — возвращает результат первого успешно исполненного Promise. Отклоняется только если все Promise завершились ошибкой.

Практические рекомендации

1. Обработка ошибок: Всегда используйте .catch() или try/catch с async/await для Promise.all(), так как одна ошибка прерывает весь процесс.
2. Ограничение параллелизма: При работе с большим количеством Promise (например, сотни запросов) могут возникнуть проблемы с производительностью. В таких случаях используют паттерны типа «пула» (pool) или библиотеки типа p-limit.
3. Сочетание с async/await: Promise.all() отлично работает с современным синтаксисом:

async function fetchAllData() {
  try {
    const [users, posts, comments] = await Promise.all([
      fetchUsers(),
      fetchPosts(),
      fetchComments()
    ]);
    console.log(users, posts, comments);
  } catch (error) {
    console.error('Не удалось загрузить данные:', error);
  }
}

Promise.all() остаётся фундаментальным инструментом для параллельного выполнения асинхронных операций в JavaScript. Его правильное использование значительно улучшает производительность веб-приложений, особенно когда нужно загружать несколько независимых ресурсов одновременно. Понимание различий между Promise.all(), Promise.allSettled(), Promise.race() и Promise.any() позволяет выбирать оптимальный подход для разных сценариев работы с асинхронным кодом.