Функция Promise.all () в JavaScript: полное руководство

Обещания в JavaScript — это один из надежных API, который помогает нам выполнять асинхронные операции. В некоторых компьютерных системах они могут выполняться параллельно или в некотором смысле одновременно, в то время как в других системах они могут выполняться последовательно.

Для такого непредсказуемого поведения обещаний не должно быть зависимости ни от одного обещания от порядка выполнения обещаний.

Promise.all () Функция в JavaScript

Promise.all () — это встроенная функция JavaScript, которая возвращает одно обещание, которое разрешается, когда все обещания, переданные как итерабельность, разрешены, или когда итерируемый объект не содержит обещаний. Метод Promise.all () может быть полезен для агрегирования результатов нескольких обещаний.

Метод Promise.all () отклоняет по причине первого обещания, которое отклоняет, или с ошибкой, обнаруженной первым аргументом, если этот аргумент перехватил ошибка внутри него с использованием блоков try/catch/throw .

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

Метод Promise all () отклоняется с указанием причины первого отклоненного обещания. Нет никакого особого порядка в выполнении массива данных промисов.

Например, предположим, что у вас есть одиннадцать (11) обещаний (асинхронная операция для выполнения сетевого вызова или базы данных связь).

В этом случае вы должны знать, когда все обещания будут разрешены, или дождаться разрешения всех обещаний.

Итак, вы передаете все десять обещаний в Promise. все. Затем сам Promise.all () как обещание будет разрешен после того, как будут разрешены все десять обещаний или любое из десяти обещаний будет отклонено с ошибкой.

Если какое-либо из переданных обещаний отклоняется, функция Promise.all () асинхронно отклоняет значение отклоненного обещания, независимо от того, какие другие обещания были разрешены или нет. Это не имеет никакого отношения к этому.

 Promise.all (итерация); 

Параметры

Параметр iterable — это такой объект, как массив или строка.

Return Значение

Функция Javascript Promise all () возвращает одно из следующих значений.

1. уже разрешено Promise, если переданный итеративный элемент пуст.
2. асинхронно разрешается Promise, если переданный итеративный элемент не содержит обещаний.
3. ожидающее обещание во всех остальных случаях. Затем обещание разрешается/отклоняется асинхронно (как только стек становится пустым), когда все обещания в данной итерации разрешены или если какое-либо из обещаний отклоняется. Возвращаемые значения будут в порядке переданных обещаний, независимо от полного порядка.

Promise.all — это обещание, которое принимает массив обещаний в качестве входных данных (итерация) . Затем он разрешается, когда выполняются все обещания или любое из них отклоняется.

Давайте рассмотрим простой пример. Давайте создадим один файл с именем app.js и напишем следующий код.

//app.jsconst p1 = Promise.resolve (21); const p2 =  110470116021; const p3 = new Promise ((resolve, reject) => {//eslint-disable-line no-unused-varssetTimeout (() => {resolve ('AppDividend');}, 1000);}); Promise  .all ([p1, p2, p3]). then (values ​​=> {console.log (values);}); 

Здесь мы определили три обещания. Затем мы установили метод Promise all () для возврата одного обещания на основе трех обещаний. В этом примере все три обещания разрешаются, поэтому функция Promise.all () разрешается и выдает выходные данные всех трех обещаний в виде массива.

Результат следующий. Я использую Node.js для запуска файла, набрав приложение node.

Отклонение Promise.all ()

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

Здесь следует отметить, что порядок элементов результирующего массива такой же, как и в его исходных обещаниях. Несмотря на то, что первое обещание занимает больше всего времени для разрешения, оно все равно появляется первым в массиве результатов.

Если одно обещание отклоняет, Promise.all немедленно отклоняет, полностью забывая о других в список. Их результаты игнорируются.

За кулисами происходит то, что если одно обещание не выполняется, другие будут продолжать выполняться, но Promise.all () больше не будет их отслеживать. Они, вероятно, завершат свое заключение, но их результаты будут проигнорированы.

Давайте рассмотрим сценарий, при котором одно из вышеперечисленных обещаний не выполняется.

//app.jsconst  p1 = Promise.resolve (21); const p2 = new Promise ((resolve, reject) => {//eslint-disable-line no-unused-varssetTimeout (() => {reject (новая ошибка ('отклонение')  );}, 1000);}); const p3 = new Promise ((resolve, reject) => {//eslint-disable-line no-unused-varssetTimeout (() => {resolve ('AppDividend');}  , 1000);}); Promise.all ([p1, p2, p3]). Then (values ​​=> {console.log (values);}); 

В приведенном выше примере второе обещание отклоняется; поэтому окончательный вывод будет выдавать ошибку.

Promise .all () отклоняется, если отклоняется какой-либо из элементов. Например, если вы передадите четыре обещания, которые разрешаются после тайм-аута, и одно обещание, которое отклоняется немедленно, тогда Promise.all () отклонит немедленно.

Видите ли, мы получаем такую ​​ошибку, потому что мы отклонили одно обещание, и последнее обещание также будет отклонено.

Эту практику можно изменить, обработав возможные отклонения.

//app.jsconst p1  = Promise.resolve (21); const p2 = new Promise ((resolve, reject) => {//eslint-disable-line no-unused-varssetTimeout (() => {reject (новая ошибка ('отклонение'))  ;}, 1000);}); const p3 = new Promise ((resolve, reject) => {//eslint-disable-line no-unused-varssetTimeout (() => {resolve ('AppDividend');},  1000);}); Promise.all ([p1.catch (error => {return error;}), p2.catch (error => {return error;}), p3.catch (error => {return error;  }),]). then (values ​​=> {console.log (values ​​[0]); console.log (values ​​[1]); console.log (values ​​[2]);}); 

В приведенном выше примере мы отлавливаем эти ошибки внутри блока all (), если есть профессиональные mises отклоняют с ошибкой, а затем отображают значения каждого обещания. Результат следующий.

Если одно из обещаний reject, Promise.all () немедленно отклоняет, полностью забывая о других в списке. Их результаты игнорируются.

Например, если существует несколько вызовов AJAX, и один из них не работает, другие будут продолжать выполняться, но Promise.all () больше не будет их отслеживать. Вероятно, они урегулируются, но результат будет проигнорирован.

Promise.all не делает ничего, чтобы их отменить, поскольку в обещаниях нет понятия «отмена».

Метод Promise .all () подходит для случаев « все или ничего» .

Примеры использования метода Promise.all ()

Предположим, что вам нужно выполнить огромное количество асинхронных операций, таких как отправка массового push-уведомления тысячам подписчиков.

Простой псевдокод будет следующим.

 for (let x = 0; x  
 Приведенный выше пример прост, но не очень эффективен.  
 
 Стек станет слишком тяжелым, и в какой-то момент JavaScript будет иметь огромное количество открытых HTTP-соединений, что может убить сервер. 
 
 A  простой и эффективный подход - делать это партиями.  Возьмите первых 500 пользователей, активируйте push-уведомление и дождитесь закрытия всех HTTP-соединений.  Затем возьмите следующий пакет для его обработки и так далее. 
 
 См. Следующий код. 
 
 const sendNotificationForUsers = async (users) => {const usersLength = users  .length for (let i = 0; i  {//Размер пакета равен 100. Мы  обрабатываются в наборе из 100 пользователей. return triggerNotificationForUser (user)//Асинхронная функция для отправки почты.. catch (e => console.log (`Ошибка при отправке уведомления для $ {user} - $ {e}`))//Выявить ошибку, если что-то пойдет не так.  Чтобы он не блокировал петлю.  })//запросы будут иметь не более 100 ожидающих обещаний. //Promise.all будет ждать, пока все обещания будут разрешены, а затем выполнит следующие 100. await Promise.all (requests) .catch (e => console.log (`Ошибка при отправке уведомления для пакета $ {i} -  $ {e} `))//Отловить ошибку.  }} sendNotificationForUsers (userLists) 
 Итак, вот как вы отправляете уведомление партиями. 
  Заключение  
 Метод Javascript Promise.all () - лучший способ объединить группу обещаний в одно обещание.  Это один из способов достижения параллелизма в JavaScript. 
 Возвращаемое обещание выполняется с массивом, содержащим все повторяемые значения, переданные в качестве аргумента (также значения, не являющиеся обещаниями). 

 Если передана пустая итерация, этот метод возвращает (синхронно) уже разрешенное обещание. 
 Если все переданные обещания выполняются или не являются обещаниями  , Promise, возвращаемый Promise .all, выполняется асинхронно. 

 Если какое-либо из переданных обещаний отклоняется, Promise.all () асинхронно отклоняет значение Promise, которое отклонено, независимо от того,  другие обещания не разрешены. 
 Ключевым аспектом обещаний является то, что они являются конвейером, и различные обработчики могут массировать данные в конвейере. 
  Для получения дополнительной информации о Promise вы можете прочитать статью в документации Mozilla. 
  Заключение  
 Есть пять статических  методы класса Promise: 
  Promise.all (promises)  - T  Функция ожидает выполнения всех обещаний и возвращает массив их результатов.  Если какое-либо из заданных обещаний отклоняется, это становится ошибкой метода Promise.all (), а все остальные результаты игнорируются. 
  Promise.allSettled (promises) (недавно  добавлен метод)  - функция allSettled () ожидает завершения всех обещаний и возвращает их результаты в виде массива объектов с: 
  состоянием :  «Выполнено» или «отклонено» 
  значение  (если выполнено) или причина (если отклонено). 
  Promise.race  (обещания)  - это встроенная функция JS Promise, которая ожидает выполнения первого обещания, и ее результат/ошибка становится результатом. 
  Promise.resolve  (значение)  - это встроенная функция JavaScript, которая создает обработанное обещание с заданным значением. 
  Promise.reject (error)  -  Функция Promise.reject () делает отклоненное обещание с данной ошибкой. 
 Это все для функции Javascript Promise.all (). 
   Рекомендуемые сообщения  
 Promise.resolve () 
 Promise.reject () 
 Promise.race () 
 Javascript  async/await 
 Node Async Await