Node JS Promise.all et forEach

J'ai un tableau comme une structure qui expose les méthodes asynchrones. La méthode async appelle des structures de tableau de retour qui à leur tour exposent plus de méthodes async. Je crée un autre objet JSON pour stocker les valeurs obtenues à partir de cette structure et je dois donc faire attention au suivi des références dans les rappels.

J'ai codé une solution de force brute, mais j'aimerais apprendre une solution plus idiomatique ou plus propre.

1. Le modèle doit être répétable pour n niveaux d'imbrication.
2. Je dois utiliser promise.all ou une technique similaire pour déterminer quand résoudre la routine englobante.
3. Tous les éléments n'impliqueront pas nécessairement de faire un appel asynchrone. Donc, dans une promesse imbriquée.all, je ne peux pas simplement attribuer des éléments à mes éléments de tableau JSON en fonction de l'index. Néanmoins, je dois utiliser quelque chose comme promise.all dans le forEach imbriqué pour m'assurer que toutes les attributions de propriété ont été effectuées avant de résoudre la routine englobante.
4. J'utilise la librairie bluebird promise mais ce n'est pas une exigence

Voici un code partiel -

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();

C'est assez simple avec quelques règles simples:

• Chaque fois que vous créez une promesse dans un then, renvoyez-la - toute promesse que vous ne reviendrez pas ne sera pas attendue à l'extérieur.
• Chaque fois que vous créez plusieurs promesses, .allelles - de cette façon, il attend toutes les promesses et aucune erreur de l'une d'entre elles ne sera réduite au silence.
• Chaque fois que vous emboitez then, vous pouvez généralement revenir dans le milieu - les thenchaînes ont généralement au plus 1 niveau de profondeur.
• Chaque fois que vous effectuez des EI, cela devrait être avec une promesse - soit cela devrait être dans une promesse ou il devrait utiliser une promesse pour signaler son achèvement.

Et quelques conseils:

• Le mappage est mieux fait avec .mapqu'avecfor/push - si vous mappez des valeurs avec une fonction, mapvous permet d'exprimer de manière concise la notion d'application des actions une par une et d'agréger les résultats.
• La concurrence est meilleure que l'exécution séquentielle si elle est gratuite - il vaut mieux exécuter les choses simultanément et les attendre Promise.allque d'exécuter les choses l'une après l'autre - chacune attendant avant la suivante.

Ok, alors commençons:

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]
});

Voici un exemple simple d'utilisation de réduire. Il fonctionne en série, maintient l'ordre d'insertion et ne nécessite pas 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());
}

Et utilisez-le comme ceci:

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');
});

Nous avons trouvé utile d'envoyer un contexte facultatif en boucle. Le contexte est facultatif et partagé par toutes les itérations.

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

Votre fonction de promesse ressemblerait à ceci:

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

J'ai traversé la même situation. J'ai résolu en utilisant deux Promise.All ().

Je pense que c'était vraiment une bonne solution, alors je l'ai publiée sur npm: https://www.npmjs.com/package/promise-foreach

Je pense que votre code sera quelque chose comme ça

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)
    })

Juste pour ajouter à la solution présentée, dans mon cas, je voulais récupérer plusieurs données de Firebase pour une liste de produits. Voici comment je l'ai fait:

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]);