Node JS Promise.all and forEach

by

It’s pretty straightforward with some simple rules:

  • Whenever you create a promise in a then, return it – any promise you don’t return will not be waited for outside.
  • Whenever you create multiple promises, .all them – that way it waits for all the promises and no error from any of them are silenced.
  • Whenever you nest thens, you can typically return in the middle – then chains are usually at most 1 level deep.
  • Whenever you perform IO, it should be with a promise – either it should be in a promise or it should use a promise to signal its completion.

And some tips:

  • Mapping is better done with .map than with for/push – if you’re mapping values with a function, map lets you concisely express the notion of applying actions one by one and aggregating the results.
  • Concurrency is better than sequential execution if it’s free – it’s better to execute things concurrently and wait for them Promise.all than to execute things one after the other – each waiting before the next.

Ok, so let’s get started:

var items = [1, 2, 3, 4, 5];
var fn = function asyncMultiplyBy2(v){ // sample async action
    return new Promise(resolve => setTimeout(() => resolve(v * 2), 100));
};
// map over forEach since it returns

var actions = items.map(fn); // run the function over all items

// we now have a promises array and we want to wait for it

var results = Promise.all(actions); // pass array of promises

results.then(data => // or just .then(console.log)
    console.log(data) // [2, 4, 6, 8, 10]
);

// we can nest this of course, as I said, `then` chains:

var res2 = Promise.all([1, 2, 3, 4, 5].map(fn)).then(
    data => Promise.all(data.map(fn))
).then(function(data){
    // the next `then` is executed after the promise has returned from the previous
    // `then` fulfilled, in this case it's an aggregate promise because of 
    // the `.all` 
    return Promise.all(data.map(fn));
}).then(function(data){
    // just for good measure
    return Promise.all(data.map(fn));
});

// now to get the results:

res2.then(function(data){
    console.log(data); // [16, 32, 48, 64, 80]
});

More Related Contents:

  1. Asynchronous exception handling with bluebird promises
  2. using async await and .then together
  3. Using mongoose promises with async/await
  4. Javascript Asynchronous Exception Handling with node.js
  5. Properly batch nested promises in Node
  6. JavaScript asynchronous programming: promises vs generators
  7. When is .then(success, fail) considered an antipattern for promises?
  8. Is it bad practice to have a constructor function return a Promise?
  9. async/await always returns promise
  10. Callback after all asynchronous forEach callbacks are completed
  11. Are all javascript callbacks asynchronous? If not, how do I know which are?
  12. Promise Retry Design Patterns
  13. How to return values from async functions using async-await from function? [duplicate]
  14. Best way to call an asynchronous function within map?
  15. How to avoid long nesting of asynchronous functions in Node.js
  16. Should an async API ever throw synchronously?
  17. Handling multiple catches in promise chain
  18. How to wrap async function calls into a sync function in Node.js or Javascript?
  19. SyntaxError: Unexpected token function – Async Await Nodejs
  20. Catching Errors in JavaScript Promises with a First Level try … catch
  21. Are all Node.js callback functions asynchronous?
  22. How to implement a pseudo blocking async queue in JS/TS?
  23. Proper way to skip a then function in Q Promises
  24. Node js socket explanation
  25. javascript – Why is there a spec for sync and async modules?
  26. How do you create custom asynchronous functions in node.js?
  27. Why is node.js asynchronous?
  28. Difference of using async / await vs promises?
  29. How to use the ‘main’ parameter in package.json?
  30. Promise.all().then() resolve?

Leave a Comment