Correct way to write loops for promise.

by

If you really want a general promiseWhen() function for this and other purposes, then by all means do so, using Bergi’s simplifications. However, because of the way promises work, passing callbacks in this way is generally unnecessary and forces you to jump through complex little hoops.

As far as I can tell you’re trying :

  • to asynchronously fetch a series of user details for a collection of email addresses (at least, that’s the only scenario that makes sense).
  • to do so by building a .then() chain via recursion.
  • to maintain the original order when handling the returned results.

Defined thus, the problem is actually the one discussed under “The Collection Kerfuffle” in Promise Anti-patterns, which offers two simple solutions :

  • parallel asynchronous calls using Array.prototype.map()
  • serial asynchronous calls using Array.prototype.reduce().

The parallel approach will (straightforwardly) give the issue that you are trying to avoid – that the order of the responses is uncertain. The serial approach will build the required .then() chain – flat – no recursion. 

function fetchUserDetails(arr) {
    return arr.reduce(function(promise, email) {
        return promise.then(function() {
            return db.getUser(email).done(function(res) {
                logger.log(res);
            });
        });
    }, Promise.resolve());
}

Call as follows :

//Compose here, by whatever means, an array of email addresses.
var arrayOfEmailAddys = [...];

fetchUserDetails(arrayOfEmailAddys).then(function() {
    console.log('all done');
});

As you can see, there’s no need for the ugly outer var count or it’s associated condition function. The limit (of 10 in the question) is determined entirely by the length of the array arrayOfEmailAddys.

More Related Contents:

  1. How do I convert an existing callback API to promises?
  2. When is .then(success, fail) considered an antipattern for promises?
  3. Is “.then(function(a){ return a; })” a no-op for promises?
  4. Asynchronous exception handling with bluebird promises
  5. Object method with ES6 / Bluebird promises
  6. Handling multiple catches in promise chain
  7. Limit concurrency of promise being run
  8. Catching Errors in JavaScript Promises with a First Level try … catch
  9. Are there still reasons to use promise libraries like Q or BlueBird now that we have ES6 promises? [closed]
  10. How do I handle errors with promises?
  11. Placement of catch BEFORE and AFTER then
  12. How to promisify Node’s child_process.exec and child_process.execFile functions with Bluebird?
  13. Wait promise inside for loop
  14. Limit concurrency of pending promises
  15. How do I access previous promise results in a .then() chain?
  16. Removing nested promises
  17. Chained promises not passing on rejection
  18. Promise.all consumes all my RAM
  19. Is Node.js native Promise.all processing in parallel or sequentially?
  20. Can’t throw error from within an async promise executor function
  21. How to check if an object is a Promise?
  22. Getting a UnhandledPromiseRejectionWarning when testing using mocha/chai
  23. How can i return status inside the promise?
  24. Node exits without error and doesn’t await promise (Event callback)
  25. Nodejs express and promises not doing what I expect
  26. Promise.resolve vs new Promise(resolve)
  27. How do I use Bluebird with Angular?
  28. Why is `.catch(err => console.error(err))` discouraged?
  29. What happens if i reject / resolve multiple times in Kriskowal’s q?
  30. Using mongoose promises with async/await

Leave a Comment