Make Angular.Foreach Wait for Promise After Going to Next Object

const { of, from } = rxjs;
const { concatMap, switchMap, delay } = rxjs.operators;

const records = [1,2,3,4,5,6];

const myService = {
  doFirstTask: val => of(`${val}: from first task`).pipe(delay(500)),
  doSecondTask: val => of(`${val}: from second task`).pipe(delay(500)),
};

from(records).pipe(
  concatMap(record => myService.doFirstTask(record).pipe(
    switchMap(resultOfDoFirstTask => myService.doSecondTask(resultOfDoFirstTask))
  ))
).subscribe(resultOfDoSecondTask => {
  console.log(resultOfDoSecondTask);
});

<script src="https://cdnjs.cloudflare.com/ajax/libs/rxjs/6.6.0/rxjs.umd.min.js"></script>

Foreach with Promise not waiting on method results

If there is not exactly one suite in the obj, with exactly one spec, then your promise is either resolved not at all or multiple times.

Avoid wrapping too many things in the new Promise constructor - always promisify on the smallest possible level, and use promise chaining afterwards.

protractorParser.prototype.parseResults = function (fileName) {
    return new Promise((resolve, reject) => {
        console.log('In parseresults', fileName);
        json.readFile(fileName, function (err, obj) {
            if (err != null) {
                console.log('error reading file', err);
                reject(err);
            } else {
                resolve(obj);
            }
        });
    }).then(function(obj) {
        console.log('obj - ',obj);
        var results = [];

        for (var suite in obj) {
            var specs = obj[suite].specs;
            console.log('spec - ', specs);
            for (let i = 0; i < specs.length; i++) {
                const assert = specs[i];
                const tcR = /TC[\d]+/;
                const tc = assert.description.match(tcR);

                let Passed = 1;
                let Message = '';
                let Stack = '';
                if (assert.failedExpectations.length) {
                    const expectation = assert.failedExpectations[assert.failedExpectations.length-1];
                    Passed = 0;
                    Message = expectation.message;
                    Stack = expectation.stack.split('\n')[1].trim();
                }
                if (tc != null) {
                    const time = moment().utcOffset(config.get('settings.timeOffset')).format('YYYY-MM-DDTHH:mm:ss');
                    const promise = utility.TestDataManager.insertAutomationResults(tc[0], assert.description, Passed, process.env.testBuild, 'P', Message, Stack, 0, time, '');
                    results.push(promise.catch(err => {
                        console.log('Posting to Database failed ', err);
                        throw err;
                    }));
                } else {
                    console.log('no test case found for test: ' + assert.description + ' -- skipping');
                    // I don't think you want to `throw err` here, right?
                }
            }
        }
        return Promise.all(results);
    });
};

Best way to wait for .forEach() to complete

If there is no asynchronous code inside the forEach, forEach is not asynchronous, for example in this code:

array.forEach(function(item){ 
    //iterate on something 
});
alert("Foreach DONE !");

you will see the alert after forEach finished.

Otherwise (You have something asynchronous inside), you can wrap the forEach loop in a Promise:

var bar = new Promise((resolve, reject) => {
    foo.forEach((value, index, array) => {
        console.log(value);
        if (index === array.length -1) resolve();
    });
});

bar.then(() => {
    console.log('All done!');
});

Credit: @rolando-benjamin-vaz-ferreira

Javascript/Angularjs : wait for promise to be fulfilled before going to the next iteration in foreach Loop

You could define a function to process the entries recursively like so:

function updateEntries(entries, i) {
  if(i < entries.length) {
    return SomeService.updateEntry(entries[i]).then(function() {
      return updateEntries(entries, i+1);
    });
  }
}
updateEntries(entriesToUpdate, 0);

Or you could chain your promises.

var promise = SomeService.updateEntry(entriesToUpdate[0]);
for(var i = 1; i < entriesToUpdate.length; i++) {
  promise = promise.then(function() {
    return SomeService.updateEntry(entriesToUpdate[i]);
  });
}

(These examples might not work; I'm not familiar with AngularJS promises. Only ES6 promises)

How to wait until Javascript forEach loop is finished before proceeding to next sep

Create an array of promises then use Promise.all to await their resolution/rejection using async/await.

// async/await - create an array of promises
// from function2, then await until Promise.all has
// fully resolved/rejected
async function1() {
  let arr = [1, 2, 3, 4, 5];
  const promises = arr.map((num) => function2(num));
  await Promise.all(promises);
  function3();
}

function2(number) {
  return axios.post('/internal-url/action/' + number);
}

function3() {
  console.log('reloading data...');
  /* DB call to reload data */
  console.log('data is reloaded');
}

Using async/await with a forEach loop

Sure the code does work, but I'm pretty sure it doesn't do what you expect it to do. It just fires off multiple asynchronous calls, but the printFiles function does immediately return after that.

Reading in sequence

If you want to read the files in sequence, you cannot use forEach indeed. Just use a modern for … of loop instead, in which await will work as expected:

async function printFiles () {
  const files = await getFilePaths();

  for (const file of files) {
    const contents = await fs.readFile(file, 'utf8');
    console.log(contents);
  }
}

Reading in parallel

If you want to read the files in parallel, you cannot use forEach indeed. Each of the async callback function calls does return a promise, but you're throwing them away instead of awaiting them. Just use map instead, and you can await the array of promises that you'll get with Promise.all:

async function printFiles () {
  const files = await getFilePaths();

  await Promise.all(files.map(async (file) => {
    const contents = await fs.readFile(file, 'utf8')
    console.log(contents)
  }));
}

---

Related Topics