Node JS Promise.all и forEach


120

У меня есть структура, подобная массиву, которая предоставляет асинхронные методы. Асинхронный метод вызывает структуры массива возврата, которые, в свою очередь, предоставляют больше асинхронных методов. Я создаю еще один объект JSON для хранения значений, полученных из этой структуры, поэтому мне нужно быть осторожным при отслеживании ссылок в обратных вызовах.

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

  1. Шаблон должен повторяться для n уровней вложенности.
  2. Мне нужно использовать обещание.all или какой-либо подобный метод, чтобы определить, когда разрешить процедуру включения.
  3. Не каждый элемент обязательно требует выполнения асинхронного вызова. Итак, во вложенном обещании я не могу просто назначать элементы массива JSON на основе индекса. Тем не менее мне нужно использовать что-то вроде обещания.all во вложенном forEach, чтобы гарантировать, что все присвоения свойств были выполнены до разрешения включающей подпрограммы.
  4. Я использую библиотеку обещаний bluebird, но это не требование

Вот частичный код -

var jsonItems = [];

items.forEach(function(item){

  var jsonItem = {};
  jsonItem.name = item.name;
  item.getThings().then(function(things){
  // or Promise.all(allItemGetThingCalls, function(things){

    things.forEach(function(thing, index){

      jsonItems[index].thingName = thing.name;
      if(thing.type === 'file'){

        thing.getFile().then(function(file){ //or promise.all?

          jsonItems[index].filesize = file.getSize();

Это ссылка на рабочий источник, который я хочу улучшить. github.com/pebanfield/change-view-service/blob/master/src/…
user3205931

1
Я вижу в образце, который вы используете bluebird, bluebird на самом деле делает вашу жизнь еще проще с Promise.map(одновременным) и Promise.each(последовательным) в этом случае, также примечание Promise.deferустарело - код в моем ответе показывает, как этого избежать, возвращая обещания. Обещания - это возвращаемые значения.
Benjamin Gruenbaum

Ответы:


369

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

  • Каждый раз, когда вы создаете обещание в then, возвращайте его - любое обещание, которое вы не вернете, не будет ожидаться снаружи.
  • Когда вы создаете несколько обещаний, .allони - таким образом, ожидаются все обещания, и никакие ошибки ни в одном из них не заглушаются.
  • Всякий раз, когда вы вкладываете thens, вы обычно можете вернуться в середину -then цепочки обычно не более 1 уровня в глубину.
  • Всякий раз, когда вы выполняете ввод-вывод, он должен быть с обещанием - либо он должен быть в обещании, либо он должен использовать обещание, чтобы сигнализировать о его завершении.

И несколько советов:

  • Сопоставление лучше выполнять с помощью, .mapчем сfor/push - если вы сопоставляете значения с функцией,map позволяет кратко выразить понятие применения действий по одному и агрегирования результатов.
  • Параллелизм лучше, чем последовательное выполнение, если он бесплатный - лучше выполнять вещи одновременно и ждать их, Promise.allчем выполнять одно за другим - каждое ждет раньше другого.

Итак, приступим:

var items = [1, 2, 3, 4, 5];
var fn = function asyncMultiplyBy2(v){ // sample async action
    return new Promise(resolve => setTimeout(() => resolve(v * 2), 100));
};
// map over forEach since it returns

var actions = items.map(fn); // run the function over all items

// we now have a promises array and we want to wait for it

var results = Promise.all(actions); // pass array of promises

results.then(data => // or just .then(console.log)
    console.log(data) // [2, 4, 6, 8, 10]
);

// we can nest this of course, as I said, `then` chains:

var res2 = Promise.all([1, 2, 3, 4, 5].map(fn)).then(
    data => Promise.all(data.map(fn))
).then(function(data){
    // the next `then` is executed after the promise has returned from the previous
    // `then` fulfilled, in this case it's an aggregate promise because of 
    // the `.all` 
    return Promise.all(data.map(fn));
}).then(function(data){
    // just for good measure
    return Promise.all(data.map(fn));
});

// now to get the results:

res2.then(function(data){
    console.log(data); // [16, 32, 48, 64, 80]
});

5
Ах, некоторые правила с вашей точки зрения :-)
Берги

1
@Bergi кому-то действительно стоит составить список этих правил и краткую справку по обещаниям. Возможно, мы сможем разместить его на bluebirdjs.com.
Бенджамин Грюнбаум,

поскольку я не должен просто благодарить - этот пример выглядит хорошо, и мне нравится предложение карты, однако, что делать с коллекцией объектов, только некоторые из которых имеют асинхронные методы? (Моя точка 3 выше) У меня была идея, что я абстрагирую логику синтаксического анализа для каждого элемента в функцию, а затем разрешу ее либо в ответе на асинхронный вызов, либо там, где не было асинхронного вызова, просто разрешите его. Имеет ли это смысл?
user3205931

Мне также нужно, чтобы функция карты возвращала как объект json, который я создаю, так и результат асинхронного вызова, который мне нужно сделать, поэтому я тоже не уверен, как это сделать - наконец, все это должно быть рекурсивным, поскольку я хожу по каталогу структура - я все еще жую это, но платная работа
мешает

2
@ user3205931 обещания просты, а не легки , то есть - они не так знакомы, как другие вещи, но как только вы их изучите, их намного лучше использовать. Держись, ты получишь это :)
Бенджамин Грюнбаум

42

Вот простой пример использования reduce. Он работает последовательно, поддерживает порядок вставки и не требует Bluebird.

/**
 * 
 * @param items An array of items.
 * @param fn A function that accepts an item from the array and returns a promise.
 * @returns {Promise}
 */
function forEachPromise(items, fn) {
    return items.reduce(function (promise, item) {
        return promise.then(function () {
            return fn(item);
        });
    }, Promise.resolve());
}

И используйте это так:

var items = ['a', 'b', 'c'];

function logItem(item) {
    return new Promise((resolve, reject) => {
        process.nextTick(() => {
            console.log(item);
            resolve();
        })
    });
}

forEachPromise(items, logItem).then(() => {
    console.log('done');
});

Мы сочли полезным отправить дополнительный контекст в цикл. Контекст не является обязательным и используется всеми итерациями.

function forEachPromise(items, fn, context) {
    return items.reduce(function (promise, item) {
        return promise.then(function () {
            return fn(item, context);
        });
    }, Promise.resolve());
}

Ваша функция обещания будет выглядеть так:

function logItem(item, context) {
    return new Promise((resolve, reject) => {
        process.nextTick(() => {
            console.log(item);
            context.itemCount++;
            resolve();
        })
    });
}

Спасибо за это - ваше решение сработало для меня, а другие (включая различные библиотеки npm) - нет. Вы опубликовали это в npm?
SamF

Спасибо. Функция предполагает, что все обещания разрешены. Как мы справляемся с отклоненными обещаниями? Кроме того, как мы обрабатываем успешные обещания со значением?
oyalhi

@oyalhi Я бы предложил использовать «контекст» и добавить массив отклоненных входных параметров, сопоставленных с ошибкой. Это действительно для каждого варианта использования, так как некоторые захотят игнорировать все оставшиеся обещания, а некоторые нет. Для возвращаемого значения вы также можете использовать аналогичный подход.
Стивен Спунгин

1

У меня была такая же ситуация. Я решил использовать два Promise.All ().

Я считаю, что это действительно хорошее решение, поэтому я опубликовал его на npm: https://www.npmjs.com/package/promise-foreach

Я думаю, ваш код будет примерно таким

var promiseForeach = require('promise-foreach')
var jsonItems = [];
promiseForeach.each(jsonItems,
    [function (jsonItems){
        return new Promise(function(resolve, reject){
            if(jsonItems.type === 'file'){
                jsonItems.getFile().then(function(file){ //or promise.all?
                    resolve(file.getSize())
                })
            }
        })
    }],
    function (result, current) {
        return {
            type: current.type,
            size: jsonItems.result[0]
        }
    },
    function (err, newList) {
        if (err) {
            console.error(err)
            return;
        }
        console.log('new jsonItems : ', newList)
    })

0

Просто чтобы добавить к представленному решению, в моем случае я хотел получить несколько данных из Firebase для списка продуктов. Вот как я это сделал:

useEffect(() => {
  const fn = p => firebase.firestore().doc(`products/${p.id}`).get();
  const actions = data.occasion.products.map(fn);
  const results = Promise.all(actions);
  results.then(data => {
    const newProducts = [];
    data.forEach(p => {
      newProducts.push({ id: p.id, ...p.data() });
    });
    setProducts(newProducts);
  });
}, [data]);
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.