Question

我开始使用嵌套的promise映射，并在调用函数中的resolve之前看到外部.then（）块打印一个null结果。

我觉得我必须以某种方式弄乱语法。我已经将这个例子剥离了：

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函数解析时，它们被分配给返回对象它似乎工作正常，除了其中一个承诺功能有时会延迟，因为它进行了一些计算当发生这种情况时，它将被遗漏在返回值之外，因为它还没有解决。

它是否应该等到具有Promise.all的内部循环在从外部循环返回之前解析？

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

编辑：根据@ 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（）块在嵌套的promise解析之前变为null

1 个答案: