await with array foreach containing async await [duplicate]

Question

In node.js I need to use a function procesMultipleCandidates () which contains Array.foreach which process insert every element into db. but the entire function should return response after completing all insertion operation

JavaScript Code

async function procesMultipleCandidates (data) {
  let generatedResponse = []
  await data.forEach(async (elem) => {
    try {    
          
           // here candidate data is inserted into  
           let insertResponse = await insertionInCandidate(elem) 
           //and response need to be added into final response array 
           generatedResponse.push(insertResponse)
    } catch (error) {
    console.log('error'+ error);
    }
  })
  console.log('complete all') // gets loged first
  return generatedResponse // return without waiting for process of 
}

And as described above last return statement not waiting for the foreach execution to complete first.

Your data.forEach itself blocks the execution until the callback finishes execution. You need not use 'await' at that point. — divine
– divine, Commented Aug 8, 2018 at 4:41
this was helpful for me stackoverflow.com/questions/37576685/… — frederj
– frederj, Commented Oct 8, 2020 at 17:30

SimpleJ · Accepted Answer · 2021-11-25 22:29:11Z

78

Use Array.prototype.map and Promise.all:

async function procesMultipleCandidates (data) {
  let generatedResponse = []
  await Promise.all(data.map(async (elem) => {
    try {
      // here candidate data is inserted into  
      let insertResponse = await insertionInCandidate(elem)  
      // and response need to be added into final response array 
      generatedResponse.push(insertResponse)
    } catch (error) {
      console.log('error'+ error);
    }
  }))
  console.log('complete all') // gets loged first
  return generatedResponse // return without waiting for process of 
}

Or use a for/of loop if you don't want the loop run concurrently:

async function procesMultipleCandidates (data) {
  let generatedResponse = []
  for(let elem of data) {
    try {
      // here candidate data is inserted into  
      let insertResponse = await insertionInCandidate(elem)  
      // and response need to be added into final response array 
      generatedResponse.push(insertResponse)
    } catch (error) {
      console.log('error'+ error);
    }
  }
  console.log('complete all') // gets loged first
  return generatedResponse // return without waiting for process of 
}

edited Nov 25, 2021 at 22:29

answered Aug 8, 2018 at 4:39

SimpleJ

14.9k13 gold badges62 silver badges98 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Grijan Over a year ago

using for/of is way simpler and works perfectly!

Izlia Over a year ago

Hello! If it's not too late yet, I have a somewhat similar problem and I asked a question, could you help me please?

Geet Choubey · Accepted Answer · 2020-08-27 07:07:42Z

9

Array.prototype.forEach() tries to execute sequentially and you may not always get the expected result.

Array.prototype.map() is the widely used for creating Promises using data and then resolved using await Promise.all([])

using .map() function, all the promises are resolved in parallel and if you happen to call an API you may end up getting error 429: Too many Requests

To execute all the promises sequentially, you can use for ...of.

const array1 = ['a', 'b', 'c'];

for (const element of array1) {
  console.log(element);
}

MDN Reference

answered Aug 27, 2020 at 7:07

Geet Choubey

1,0757 silver badges23 bronze badges

Comments

juliojordan · Accepted Answer · 2020-12-10 17:34:04Z

3

As far as I'm concern, for of works better with asynchrony than forEach. Anyway, in this case, if you only care for the aggregated result, I think this could be a solution.

async function procesMultipleCandidates(data) {
  const promises = data.map(insertionInCandidate);
  return await Promise.all(promises);
}

answered Dec 10, 2020 at 17:34

juliojordan

312 bronze badges

Comments

CertainPerformance · Accepted Answer · 2018-08-08 04:38:12Z

0

Use Promise.all instead, which will resolve once all Promises in the array passed to it have resolved. The syntax will probably be simplified if you use and return a plain Promise chain rather than async/await:

const procesMultipleCandidates = data => Promise.all(
  data.map(insertionInCandidate)
)
.catch(err => {
  console.log('err: ' + err);
});

Note that if there's an error, procesMultipleCandidates will currently return a resolved Promise rather than rejecting - it might be a better idea to have the consumer of procesMultipleCandidates handle errors, so that it can handle them appropriately (rather than simply console.logging it).

answered Aug 8, 2018 at 4:38

CertainPerformance

373k55 gold badges354 silver badges359 bronze badges

2 Comments

Shankar Over a year ago

in your solution, how the response of each insertionInCandidate() can be pushed in one final response array?

CertainPerformance Over a year ago

The .map is transforming each item in data into a Promise that resolves to the result of calling insertionInCandidate with the item - pass an array of those Promises to Promise.all, and the Promise.all will resolve to an array of those values. No modifications to the code are needed - it's quite terse and simple.

Collectives™ on Stack Overflow

await with array foreach containing async await [duplicate]

4 Answers 4

2 Comments

Comments

Comments

2 Comments

Linked

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

2 Comments

Comments

Comments

2 Comments

Linked

Related