CODEWITHSUNDEEP
javascriptarraysnode.jspromisebluebird
GForce
GForce

Reputation: 21

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

I'm kicking off a nested promise mapping and seeing the outer .then() block print a null result before the resolve in the function is called.

I feel like I must be messing up the syntax somehow. I've made this stripped down example:

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

What I'm trying to do is loop over an outer array that has some values that I need.
These values include a nested inner array that I must also loop over to get some values.
In the inner loop I pass the outer and inner values to promise functions in a Promise.all.
When the promise functions resolve they get assigned to a return object.
It seems to be working fine except for one of the promise functions sometimes has a delay as it's doing some calculations.
When this happens it is left out of the return value because it hasn't resolved yet.

Shouldn't it wait until the inner loop with Promise.all resolves before it returns from the outer loop?

Can you point me in the right direction?

EDIT: Ended up with this solution based on @Thomas's suggestion:

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

Upvotes: 0

Views: 1179

Answers (1)

Thomas
Thomas

Reputation: 12637

I'm not entirely sure I get your problem from your stripped down example, but I think what you want to do here is this:

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

Upvotes: 0

Related Questions