Conclude the execution of promises after a for loop

Question

Conclude the execution of promises after a for loop

I'm looking to enhance my code by ensuring that it waits for the asynchronous query called prom to finish before resetting the array and restarting the first for loop. This way, the array will be cleared before the loop begins again.

items = [];
var promises = [];
    for (var i = 0; i < userArray.length; i++) {

        items.length = 0;
        for (var i2 = 0; i2 < test.length; i2++) {

           var UserFavourite = Parse.Object.extend("UserFavourite");
            var queryUserFav = new Parse.Query(UserFavourite);
            queryUserFav.equalTo('item', test[i2].get('item'));
            queryUserFav.equalTo('school', test[i2].get('school'));
            queryUserFav.equalTo('user1', userArray[i])
            var prom = queryUserFav.find().then(function(res) {

                    for (var i3 = 0; i3 < res.length; i3++){
                        var item = res[i3];
                        var itemName = item.get('item');
                        items.push(itemName);
                        console.log(items)

                    }
                    return items;

            });
            promises.push(prom);

        }
        //return Parse.Promise.when.apply(Parse.Promise, promises); I have tried it here but
        // this just stops the first for loop after its first loop

    }
    return Parse.Promise.when.apply(Parse.Promise, promises);

javascript arrays parse-platform cloud promise

Answer 1

Answer №1

To achieve your goal, you need to create a series of promises, each corresponding to an item in an array.

It would be convenient if JavaScript had a feature similar to .NET's await keyword, allowing you to use:

 await Parse.Promise.when(promises)

This would enable the promise code to execute and then resume running any code after the await. Unfortunately, JavaScript does not offer this functionality.

Another strategy involves maintaining an index variable. After processing each set of queries, increment the index to move on to the next set of values.

 function parseForUser(user) {
      var promises = [];
      for (var i2 = 0; i2 < test.length; i2++) {
        var items = [];
        var UserFavourite = Parse.Object.extend("UserFavourite");
        var queryUserFav = new Parse.Query(UserFavourite);
        queryUserFav.equalTo('item', test[i2].get('item'));
        queryUserFav.equalTo('school', test[i2].get('school'));
        queryUserFav.equalTo('user1', user)
        var prom = queryUserFav.find().then(function(res) {
                for (var i3 = 0; i3 < res.length; i3++){
                    var item = res[i3];
                    var itemName = item.get('item');
                    items.push(itemName);
                    console.log(items)

                }
                return items;
        });
        promises.push(prom);
      }
      return Parse.Promise.when(promises);

 }


 function parseUserArray(userArray) {
     var returnPromise = new Parse.Promise(); // Do you have to call it via new? 
                                              //The documentation isn't clear.
     var index = 0;
     var doNext = function() {
         if(index < userArray.length) {
            var promise = parseForUser(userArray[index++]);
            promise.done(doNext);
         } else {
             returnPromise.resolve(); 
         }
     }
     doNext();
     return returnPromise;
 }

 var parseUserArrayPromise = parseUserArray(userArray);

Answer 2

To achieve your goal, you need to create a series of promises, each corresponding to an item in an array.

It would be convenient if JavaScript had a feature similar to .NET's await keyword, allowing you to use:

 await Parse.Promise.when(promises)

This would enable the promise code to execute and then resume running any code after the await. Unfortunately, JavaScript does not offer this functionality.

Another strategy involves maintaining an index variable. After processing each set of queries, increment the index to move on to the next set of values.

 function parseForUser(user) {
      var promises = [];
      for (var i2 = 0; i2 < test.length; i2++) {
        var items = [];
        var UserFavourite = Parse.Object.extend("UserFavourite");
        var queryUserFav = new Parse.Query(UserFavourite);
        queryUserFav.equalTo('item', test[i2].get('item'));
        queryUserFav.equalTo('school', test[i2].get('school'));
        queryUserFav.equalTo('user1', user)
        var prom = queryUserFav.find().then(function(res) {
                for (var i3 = 0; i3 < res.length; i3++){
                    var item = res[i3];
                    var itemName = item.get('item');
                    items.push(itemName);
                    console.log(items)

                }
                return items;
        });
        promises.push(prom);
      }
      return Parse.Promise.when(promises);

 }


 function parseUserArray(userArray) {
     var returnPromise = new Parse.Promise(); // Do you have to call it via new? 
                                              //The documentation isn't clear.
     var index = 0;
     var doNext = function() {
         if(index < userArray.length) {
            var promise = parseForUser(userArray[index++]);
            promise.done(doNext);
         } else {
             returnPromise.resolve(); 
         }
     }
     doNext();
     return returnPromise;
 }

 var parseUserArrayPromise = parseUserArray(userArray);

Answer 3

Answer №2

Just my two cents...

In this approach, we deviate slightly from @AndrewShepherd's method by leveraging the promise returned by asyncProcessUser() in two ways.

Firstly, for managing the flow - ensuring the asynchronous sequencing of the inner loop.
Secondly, for providing an array of results that contribute to the final array, eliminating the necessity for an outer promises array.

function parseUserArray(userArray, test) {

    // This function, now portrayed as a .map(), processes a single user asynchronously against all test items,
    // returning a promise of an array of results.
    function asyncProcessUser(user) {
        return Parse.Promise.when(test.map(function(dataItem) {
            return (new Parse.Query(Parse.Object.extend("UserFavourite")))
                .equalTo('item', dataItem.get('item'))
                .equalTo('school', dataItem.get('school'))
                .equalTo('user1', user)
                .find().then(function(res) {
                    return res.map(function(r) {
                        return r.get('item');
                    });
                });
        })).then(function() {
            return Array.prototype.slice.apply(arguments).reduce(function(arr, arr_) {
                return arr.concat(arr_);
            }, []);
        });
    }

    // This section, converted to a .reduce(), executes a series of asynchronous tasks (previously in the inner loop).
    // `userArray.reduce(...)` yields a promise of an array of objects returned by `r.get('item')` above.
    return userArray.reduce( function(p, user) {
        return p.then(function(arr) {
            return asyncProcessUser(user).then(function(arr_) {
                return arr.concat(arr_);
            });
        });
    }, Parse.Promise.as([]) );//† "returns a new promise that is resolved with a given value".
}

† : More insights on Parse.Promise.as()

When stripped of the comments, the code becomes more concise.

The principle is exemplified here. Regardless of the jQuery promises in the demo, the core concept remains.

Answer 4

Just my two cents...

In this approach, we deviate slightly from @AndrewShepherd's method by leveraging the promise returned by asyncProcessUser() in two ways.

Firstly, for managing the flow - ensuring the asynchronous sequencing of the inner loop.
Secondly, for providing an array of results that contribute to the final array, eliminating the necessity for an outer promises array.

function parseUserArray(userArray, test) {

    // This function, now portrayed as a .map(), processes a single user asynchronously against all test items,
    // returning a promise of an array of results.
    function asyncProcessUser(user) {
        return Parse.Promise.when(test.map(function(dataItem) {
            return (new Parse.Query(Parse.Object.extend("UserFavourite")))
                .equalTo('item', dataItem.get('item'))
                .equalTo('school', dataItem.get('school'))
                .equalTo('user1', user)
                .find().then(function(res) {
                    return res.map(function(r) {
                        return r.get('item');
                    });
                });
        })).then(function() {
            return Array.prototype.slice.apply(arguments).reduce(function(arr, arr_) {
                return arr.concat(arr_);
            }, []);
        });
    }

    // This section, converted to a .reduce(), executes a series of asynchronous tasks (previously in the inner loop).
    // `userArray.reduce(...)` yields a promise of an array of objects returned by `r.get('item')` above.
    return userArray.reduce( function(p, user) {
        return p.then(function(arr) {
            return asyncProcessUser(user).then(function(arr_) {
                return arr.concat(arr_);
            });
        });
    }, Parse.Promise.as([]) );//† "returns a new promise that is resolved with a given value".
}

† : More insights on Parse.Promise.as()

When stripped of the comments, the code becomes more concise.

The principle is exemplified here. Regardless of the jQuery promises in the demo, the core concept remains.

Answer 5

Answer №3

Utilize this

function scanForUser(user) {
      var promises = [];
      for (var i2 = 0; i2 < test.length; i2++) {
        var items = [];
        var UserFavorite = Parse.Object.extend("UserFavorite");
        var queryUserFav = new Parse.Query(UserFavorite);
        queryUserFav.equalTo('item', test[i2].get('item'));
        queryUserFav.equalTo('school', test[i2].get('school'));
        queryUserFav.equalTo('user1', user)
        var prom = queryUserFav.find().then(function(res) {
                for (var i3 = 0; i3 < res.length; i3++){
                    var item = res[i3];
                    var itemName = item.get('item');
                    items.push(itemName);
                    console.log(items)

                }
                return items;
        });
        promises.push(prom);
      }
      return Parse.Promise.when(promises);

 }


 function scanUserArray(userArray) {
     var returnPromise = new Parse.Promise(); // Do you have to call it via new? 
                                              //The documentation isn't clear.
     var index = 0;
     var doNext = function() {
         if(index < userArray.length) {
            var promise = scanForUser(userArray[index++]);
            promise.done(doNext);
         } else {
             returnPromise.resolve(); 
         }
     }
     doNext();
     return returnPromise;
 }

Simply copy and paste

Answer 6

Utilize this

function scanForUser(user) {
      var promises = [];
      for (var i2 = 0; i2 < test.length; i2++) {
        var items = [];
        var UserFavorite = Parse.Object.extend("UserFavorite");
        var queryUserFav = new Parse.Query(UserFavorite);
        queryUserFav.equalTo('item', test[i2].get('item'));
        queryUserFav.equalTo('school', test[i2].get('school'));
        queryUserFav.equalTo('user1', user)
        var prom = queryUserFav.find().then(function(res) {
                for (var i3 = 0; i3 < res.length; i3++){
                    var item = res[i3];
                    var itemName = item.get('item');
                    items.push(itemName);
                    console.log(items)

                }
                return items;
        });
        promises.push(prom);
      }
      return Parse.Promise.when(promises);

 }


 function scanUserArray(userArray) {
     var returnPromise = new Parse.Promise(); // Do you have to call it via new? 
                                              //The documentation isn't clear.
     var index = 0;
     var doNext = function() {
         if(index < userArray.length) {
            var promise = scanForUser(userArray[index++]);
            promise.done(doNext);
         } else {
             returnPromise.resolve(); 
         }
     }
     doNext();
     return returnPromise;
 }

Simply copy and paste

Conclude the execution of promises after a for loop

Answer №1

Answer №2

Answer №3

Similar questions

Angular often uses the JavaScript pattern for development

Deliver an assured result to a variable within the angular.extend() function

How can we use the nth-of-type selector to target a set of eight elements in a

Flask caches JSON files automatically

Tips for eliminating repeated values in a textbox

Implementing pagination in a table with the help of jQuery

What could be causing my Rest API request to malfunction?

Unable to fetch Rails response through Ajax

Navigating arrays containing arrays/objects and updating properties in Angular using loops

Ensuring a Fixed Delta Tooltip in lightweight-charts is essential for maintaining a seamless

Communication between Nodemailer and Mailgun

Jquery Position behaving unexpectedly during initial invocation

Duplicate values of React object properties when using .push method within a loop

Creating a Json array of strings in Android is a straightforward process that involves following a few

Tips for resolving the 'route.search' bug in Express.js

What is the process of using AJAX, JavaScript, and HTML to submit data to a remote

AngularJS allows a function to return an array value, which can be displayed in separate blocks on

The data sent within an event does not trigger reactivity

Guide on how to forward the response obtained from an Ajax call to a different HTML page

What prevents certain scenarios from being encapsulated within a try/catch block?