Encontrar la estructura de bucle correcta para garantizar que el código basado en promesas se ejecute sincrónicamente

Cuando se trabaja con código basado en promesas, la estructura de bucle correcta es esencial para garantizar la ejecución sincrónica de operaciones asincrónicas. En el escenario dado, el objetivo es construir un bucle que garantice la ejecución de "db.getUser(email).then(function(res) { logger.log(res); })" en el orden correcto durante cada iteración.

Un enfoque emplea una función personalizada "promiseWhile". Si bien este método puede resultar útil para escenarios generales, introduce una complejidad innecesaria para el caso específico en cuestión. En su lugar, una solución más sencilla es aprovechar las funciones integradas de manipulación de matrices como map() y reduce().

Promesas paralelas versus seriales

El problema radica en el requisito de mantener el orden de las respuestas, lo que elimina el uso de un enfoque paralelo a través de Array.prototype.map(). Para construir la cadena de promesa deseada con orden conservado, Array.prototype.reduce() es más adecuado.

Ejemplo:

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

Al utilizar este método, se garantiza que la ejecución de las llamadas "db.getUser" será en serie, lo que garantiza que se mantenga el orden de los resultados. El código se puede llamar de la siguiente manera:

var arrayOfEmailAddys = [...];

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

Este enfoque elimina la necesidad de bucles o condiciones complejos y garantiza la ejecución adecuada de la cadena de promesa, incluso cuando se trata de operaciones asincrónicas.