Promise 遍历嵌套数组答案

【问题标题】：Promise looping over nested arraysPromise 遍历嵌套数组
【发布时间】：2017-09-08 16:30:50
【问题描述】：

我正在与嵌套的 Promise 循环搏斗，并且无法找到有效的解决方案。

我环顾四周，发现了这个：https://stackoverflow.com/a/29396005/3560729

promiseWhile 函数似乎有我需要的东西，但我无法让嵌套返回到外循环

promiseWhile：

function promiseWhile(predicate, action) {
    function loop() {
    if (!predicate()) return;
        return Promise.resolve(action()).then(loop);
    }
    return Promise.resolve().then(loop);
}

嵌套循环：

    let outerArray = outerArrayOfObjects;
    let returnArray = [];
    let returnArrayIndex = 0;
    let outerIndex = 0;
    let outerLength = outerArray.length;
    let passObject = { }; 

    promiseWhile(function() {
        return outerIndex < outerLength;
    }, function() {
        let innerIndex = 0;
        let innerLength = outerArray[outerIndex].innerArray.length;

        passObject = {
            innerObject: outerArray[outerIndex].innerArray[innerIndex],
            returnArray: returnArray,
            returnArrayIndex: returnArrayIndex
        };
        promiseWhile(function() {
            return innerIndex < innerLength;
        }, function() {
            return new Promise(function(resolve, reject){
                Promise.all([
                    promiseFunction1(innerObject),
                    promiseFunction2(innerObject),
                    promiseFunction3(innerObject),
                ])
                    .then(function (allMappings) {
                        passObject.returnArray[returnArrayIndex++] = {
                            "result1": allMappings[0],
                            "result2": allMappings[1],
                            "result3": allMappings[2]
                        }
                        offersIndex++;
                        return resolve(passObject)
                    })
                    .catch(function (err) {
                        offersIndex++;
                        return reject(err);
                    })
            })
        })
        outerIndex++;
      }).then(function() {
        return resolve(passObject);
      });
      })
      }

我认为我的主要问题是：我在哪里处理结果？我应该如何传递值以便正确构建返回数组？

【问题讨论】：

您能否更概括地概括一下您要完成的工作？似乎您有一个数组数组，并且您想遍历每个项目并在每个项目上调用 3 个异步函数，然后将这 3 个异步调用的结果存储在一个新数组（数组？）中......是那这里发生了什么？另外：处理顺序重要吗？您是否需要知道整个过程何时完成？
我有一个包含对象数组的对象，其中一个是一个数组，然后我需要循环并在其上执行一堆 promise 函数。我最终使用了一种完全不同的方法使用蓝鸟，我会发布答案

标签： node.js promise bluebird

【解决方案1】：

上面的 promiseWhile 适合执行操作，但不适合在嵌套循环中设置值并返回结果。

我最终选择了一种使用蓝鸟的方法：

        var Promise = require('bluebird');
        let outerArray = object.outerArray;
        let returnArray = [];
        let returnIndex = 0;
        Promise.map(outerArray, function (outerArrayObject) {
            let innerArray = outerArrayObject.innerArray;
            let outerArrayValue = outerArrayObject.value;

            Promise.map(innerArray, function (innerArrayObject) {

                Promise.all([
                    PromiseFunction1(innerArrayObject),
                    PromiseFunction2(innerArrayObject),
                    PromiseFunction3(innerArrayObject),
                ])
                    .then(function (allResults) {
                        returnArray[returnIndex++] = {
                            "result1": allResults[0],
                            "result2": allResults[1],
                            "result3": allResults[2],
                            "result4": outerArrayValue,
                        }
                        return resolve(returnArray);
                    })
                    .catch(function (err) {
                        return reject(err);
                    })
            })
        })
            .then(function () {
                    return resolve(returnArray)
                }
            ).catch(function(err){
                    return reject(err);
                }
            )
        }

【讨论】：