Promise.map 函数 .then() 阻止在嵌套承诺解析之前获取 null

Question

我正在启动一个嵌套的 promise 映射并看到外部 .then() 块在调用函数中的 resolve 之前打印了一个空结果。

我觉得我一定是把语法弄乱了。我做了这个精简的例子：

const Promise = require('bluebird');
const topArray = [{outerVal1: 1,innerArray: [{innerVal1: 1,innerVal2: 2}, {innerVal1: 3,innerVal2: 4}]},{outerVal2: 2,innerArray: [{innerVal1: 5, innerVal2: 6 },  {innerVal1: 7,innerVal2: 8 }]}] ;

promiseWithoutDelay = function (innerObject) {
    return new Promise(function (resolve, reject) {
        setTimeout(function () {
            console.log("promiseWithDelay" ,innerObject);
            let returnVal = {}
            returnVal.innerVal1 = innerObject.innerVal1;
            returnVal.innerVal2 = innerObject.innerVal2;
            returnVal.delay = false;

            return resolve(returnVal);
        }, 0);
    })
}
promiseWithDelay = function (innerObject) {
    return new Promise(function (resolve, reject) {
        setTimeout(function () {
            console.log("promiseWithDelay" ,innerObject);
            let returnVal = {}

            returnVal.innerVal1 = innerObject.innerVal1;
            returnVal.innerVal2 = innerObject.innerVal2;
            returnVal.delay = true;
            return resolve(returnVal);
        }, 3000);
    })
}

test1 = function () {
    let newArray = [];
    let newArrayIndex = 0;

    Promise.map(topArray, function (outerObject) {

        Promise.map(outerObject.innerArray, function (innerObject) {

            Promise.all([
                promiseWithoutDelay(innerObject),
                promiseWithDelay(innerObject)
            ])
                .then(function (promiseResults) {
                    newArray[newArrayIndex++] = {result1: promiseResults[1], result2: promiseResults[2]}

                })
        })
    })
        .then(function () {
            return newArray;
        })
}

var result = test1();

console.log("got result ",result);

我想做的是遍历具有我需要的一些值的外部数组。
这些值包括一个嵌套的内部数组，我还必须循环它来获取一些值。
在内部循环中，我将外部值和内部值传递给 Promise.all.
中的 promise 函数当 promise 函数解析时，它们被分配给一个 return 对象。
它似乎工作正常，除了其中一个 promise 函数在进行一些计算时有时会有延迟。
发生这种情况时，它会被排除在 return 值之外，因为它尚未解析。

它不应该等到 Promise.all 的内循环解决后再从外循环 return 解决吗？

你能给我指出正确的方向吗？

编辑：根据@Thomas 的建议结束了这个解决方案：

test1 = function(){
    return Promise.map(topArray, function(outerObject){
        let oVal = outerObject.outerVal;
        return Promise.map(outerObject.innerArray, function(innerObject){
            innerObject.oVal = oVal;
            return Promise.all([ promiseWithDelay(innerObject), promiseWithoutDelay(innerObject)])
                .then(function(results) {
                    return { result1: results[0], result2: results[1], delay: results[2] } ;
                })
        })
    }).reduce(function(newArray, arr){
        return newArray.concat(arr);
    }, []);
}

Answer 1

我不完全确定我从你的精简示例中得到了你的问题，但我认为你想在这里做的是：

test1 = function(){
    return Promise.map(topArray, function(outerObject){
        return Promise.all(outerObject.innerArray)
    }).reduce(function(newArray, arr){
        return newArray.concat(arr);
    }, []);
}

Promise.map 函数 .then() 阻止在嵌套承诺解析之前获取 null

Promise.map function .then() block getting null before nested promise resolves

javascript

arrays

node.js

promise

bluebird