Finding the Correct Loop Structure to Ensure Promise-Based Code Runs Synchronously

When working with promise-based code, the correct loop structure is essential to guarantee the synchronous execution of asynchronous operations. In the given scenario, the goal is to construct a loop that ensures the execution of "db.getUser(email).then(function(res) { logger.log(res); })" in the correct order during each iteration.

One approach employs a custom "promiseWhile" function. While this method can be useful for general scenarios, it introduces unnecessary complexity for the specific case at hand. Instead, a more straightforward solution is to leverage built-in array manipulation functions like map() and reduce().

Parallel vs. Serial Promises

The problem lies in the requirement to maintain the order of the responses, which eliminates the use of a parallel approach via Array.prototype.map(). To construct the desired promise chain with preserved order, Array.prototype.reduce() is more suitable.

Example:

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());
}

By using this method, the execution of the "db.getUser" calls is guaranteed to be serial, ensuring that the order of the results is maintained. The code can be called as follows:

var arrayOfEmailAddys = [...];

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

This approach eliminates the need for complex loops or conditions and ensures the proper execution of the promise chain, even when dealing with asynchronous operations.