Цикл ожидания против Promise.all

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

await loop

for(let i = 0;i < SIZE; i++){
    await promiseCall();
}

Он будет вызывать все обещания параллельно, если какое-либо обещание отклонено, это не повлияет на другие обещания.

В ES2018 он упростился для определенной ситуации, например, если вы хотите вызвать вторую итерацию только после завершения первой итерации, обратитесь к следующему примеру.

async function printFiles () {
  const files = await getFilePaths()

  for await (const file of fs.readFile(file, 'utf8')) {
    console.info(contents)
  }
}

Promise.all()

var p1 = Promise.resolve(32);
var p2 = 123;
var p3 = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve("foo");
  }, 100);
});
Promise.all([p1, p2, p3]).then(values => { 
  console.info(values); // [32, 123, "foo"]
});

Это выполнит каждое обещание последовательно и, наконец, вернет объединенный массив оборотных значений.

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

var p1 = Promise.resolve(32);
var p2 = Promise.resolve(123);
var p3 = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve("foo");
  }, 100);
});
Promise.all([p1, p2, p3]).then(values => { 
  console.info(values); // 123
});

Основное различие между двумя подходами заключается в том, что

1. Версия await выдает запросы к серверу последовательно в цикле. Если одна из них выдает ошибку, которую не перехватят, запросы больше не выдаются. Если ошибки запроса перехватываются с помощью блоков try / catch, вы можете определить, какой из запросов завершился ошибкой, и, возможно, запрограммировать некоторую форму восстановления или даже повторить операцию.

2. Версия Promise.all будет делать запросы к серверу в параллельном или почти параллельном режиме, что ограничено ограничениями браузера на разрешенное значение максимальное количество одновременных запросов. Если один из запросов терпит неудачу, возвращенное обещание Promise.all немедленно терпит неудачу. Если какие-либо запросы были успешными и вернули данные, вы потеряете возвращенные данные. Кроме того, если какой-либо запрос завершается неудачно, все невыполненные запросы не отменяются - они были инициированы в пользовательском коде (функция insert) при создании массива обещаний.

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

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

Примечание: обещание, возвращенное из Promise.all, будет отклонено, как только одно из обещаний в данном массиве отклонится.

const SIZE = 5;
const insert = i => new Promise(resolve => {
  console.info(`started inserting ${i}`);
  setTimeout(() => {
    console.info(`inserted ${i}`);
    resolve();
  }, 300);
});

// your code
let inserts = [];
for (let i = 0; i < SIZE; i++) inserts.push(insert(i, "..string.."))
Promise.all(inserts).then(values => {
  console.info("promise all ends");
});

// requests are made concurrently

// output
// started inserting 0
// started inserting 1
// started inserting 2
// ...
// started inserting 4
// inserted 0
// inserted 1
// ...
// promise all ends

Примечание. В этом сценарии было бы проще использовать .map вместо цикла:

Promise.all(
  Array.from(Array(SIZE)).map((_, i) => insert(i,"..string.."))
).then(values => { 
    console.info("promise all ends");
});

С другой стороны, ваш пример использования await ожидает выполнения каждого обещания, прежде чем продолжить и запустить следующее:

const SIZE = 5;
const insert = i => new Promise(resolve => {
  console.info(`started inserting ${i}`);
  setTimeout(() => {
    console.info(`inserted ${i}`);
    resolve();
  }, 300);
});

let inserts = [];
(async function loop() {
  for (let i = 0; i < SIZE; i++) {
    await insert(i, "..string..")
  }
  console.info("await loop ends");
})()

// no request is made until the previous one is finished

// output
// started inserting 0
// inserted 0
// started inserting 1
// ...
// started inserting 4
// inserted 4
// await loop ends

Последствия для производительности в вышеупомянутых случаях напрямую связаны с их различным поведением.

Если «эффективный» для вашего варианта использования означает завершение запросов как можно скорее, тогда первый пример выигрывает, потому что запросы будут выполняться примерно в одно и то же время, независимо, тогда как во втором примере они будут выполняться последовательно.

С точки зрения сложности, временная сложность для вашего первого примера равна O(longestRequestTime), потому что запросы будут выполняться по существу параллельно, и, таким образом, запрос, занимающий наибольшее время, будет приводить к наихудшему сценарию.

С другой стороны, в примере await есть O(sumOfAllRequestTimes), потому что независимо от того, сколько времени занимают отдельные запросы, каждый из них должен ждать завершения предыдущего, и, таким образом, общее время всегда будет включать в себя все из них.

Проще говоря, игнорируя все другие возможные задержки из-за среды и приложения, в котором выполняется код, для 1000 запросов, каждый из которых занимает 1 с, пример Promise.all все равно займет ~ 1 с, а пример await - ~ 1000 с.

Может, картинка поможет:

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