node js wait for a function return to continue a for-loop

Question

I have a for loop which calls a function in every step.

that function calls an API and I don't know how long it takes to get a response.

what I need is to wait until function updatePE() return a value before loop goes to the next step.

 db.query("SELECT * FROM tb_table where active = true;", (err, result) => {
  if (err) {console.log('ERROR'); return; }

for (const key in Object.keys(result.rows)) {

    updatePE(result.rows[key].b,result.rows[key].s,result.rows[key].k);

}
});

What have you tried so far and did you look into callbacks or promises as possible solutions? — Sebastian Speitel, Dec 21 '18 at 14:47
From what I understand, generators tackle this kind of issue very well. Though I'm not confident enough in my understanding of them to provide a quick example just yet. — dillon.harless, Dec 21 '18 at 15:20

score 2 · Accepted Answer · answered Dec 21 '18 at 15:17

Assuming that your update function is asynchronous (Promise-based) and you can use async/await (at least Node 8.x is needed), you can write your code in a way that all the updates will happen in parallel (from the code standpoint, as in reality NodeJS operates on top of execution queue in single thread):

 // Note "async" keyword added to the function.
 // It means it'll be converted to Promise and its internal implementation
 // can use "await"
 db.query('SELECT * FROM tb_table where active = true;', async (err, result) => {
  if (err) {
    // A good idea - you should throw a proper error here
    console.log('ERROR'); return; 
  }

  // We'll collect all the promises in that array
  const updatePromises = [];
  for (const key in Object.keys(result.rows)) {
    // IMPORTANT NOTE! Updates will start executing here, but we'll
    // Wait for finishing them later
    updatePromises.push(
      updatePE(result.rows[key].b,result.rows[key].s,result.rows[key].k)
    );
  }

  // Here we wait until all the updates are finished
  await Promise.all(updatePromises);

  // Here you can put all your code that should happen *AFTER* updates are finished
});

More on async/await in JS here:

Another thing worth mentioning - your query code uses callbacks, which are considered rather obsolete in modern JS world - please check if your db library exposes Promise interface - It'll simplify your code a lot and provide a consistent way of error handling without a lot of hassle.

If you want to properly use Promises with existing code and you don't use Promise-compatible library, you can either use:

bluebird library and its amazing Promise.fromCallback or Promise.promisifyAll. More here: http://bluebirdjs.com/docs/api-reference.html
do it yourself, based on this answer: Replacing callbacks with promises in Node.js

score 0 · Answer 2 · answered Dec 21 '18 at 14:50

0

If updatePE() is a synchronous function, then It will wait for the return of that function call, if its an async function then try to put await in front of that that will until the function returns

await updatePE() //make sure updatePE() is an async function

like this

async function updatePE(param1, param2, param3){
  return new Promise((resolve, reject)=>{
    //do something and call 
    //resolve(true)
  })
}

Make sure you can call await inside an async function only, so caller function needs to be async as well

(async function(){
 db.query("SELECT * FROM tb_table where active = true;", (err, result) => {
  if (err) {console.log('ERROR'); return; }
  for (const key in Object.keys(result.rows)) {
    await updatePE(result.rows[key].b,result.rows[key].s,result.rows[key].k);
  }
 });
})()

answered Dec 21 '18 at 14:50

sudo

906
2
14
32

1

According to good JS practices (explained e.g. here: https://lavrton.com/javascript-loops-how-to-handle-async-await-6252dd3c795/), in any case when we just want to wait for multiple requests, `Promise.all` should be used in spite of using `await` directly in for loop. It's hard to tell from Rasul's question whether the code has to just wait for all the updates or has to perform them sequentially (latter being dangerous decision, in my opinion), but I suppose `Promise.all` may be a better idea. Also, your code won't work as async scope is outside code inside `db.query`. – SzybkiSasza Dec 21 '18 at 15:20
I agree, and I thought that since this is a DB operation the order of execution for this is essential, although can't tell for sure :P – sudo Dec 21 '18 at 15:26

score 0 · Answer 3 · answered Dec 21 '18 at 16:06

I highly recommend you take a look at the async library, it is a great library for this sort of things.

Now lets talk about your issue and how can it be solved. assuming updatePE is your own function I would convert that function to a promise or add a callback to it, this way you know when it finishes executing.

for example

// Promise implementation
function updatePE(x, y, z) {
   return new Promise(function(resolve, reject){
       // Do your work here and when is done resolve it
       resolve();
   });
}

// Callback implementation
function update(x, y, z, callback)
{
     // Do your work here and when is done, callback
     callback()
}

now using the async library you can do the following

// If your updatePE uses callback
async.forEach(result.rows, function(row, callback) {
     updatePE(x, y, z, function() {
        callback(null)
     });
}, function(err){
     if (err) {
        // Loop is finished with an error
     } else {
        // Loop is finished without an error
     }
});

// If your updatePE uses promise
async.forEach(result.rows, function(row, callback) {
     updatePE(x, y, z)
        .then(function(){
           callback(null)
        })
        .catch(function(err){
           callback(err)
        })
}, function(err){
     if (err) {
        // Loop is finished with an error
     } else {
        // Loop is finished without an error
     }
});

score 0 · Answer 4 · answered Dec 22 '18 at 08:44

Do it using async library. It lets you go to next iteration of a for loop only after you fire a callback. Like this:

var async = require('async');
async.forEach(Object.keys(result.rows), async function(key, cb) { 
  await updatePE(result.rows[key].b,result.rows[key].s,result.rows[key].k);
  cb();
}, function(err) {
   // Here you know that the loop has completed (with err or success).
});

Be sure to return a promise in you updatePE. Like this:

function updatePE(b, s, k) {
  return new Promise(function(resolve, reject) {
    // Your update code here.
    if(updateSuccessful) resolve();
    else reject();
  });
}

node js wait for a function return to continue a for-loop

4 Answers4