Considere el siguiente código que lee una matriz de archivos de manera serial / secuencial. readFilesdevuelve una promesa, que se resuelve solo una vez que todos los archivos se han leído en secuencia.

var readFile = function(file) {
  ... // Returns a promise.
};

var readFiles = function(files) {
  return new Promise((resolve, reject) => 

    var readSequential = function(index) {
      if (index >= files.length) {
        resolve();
      } else {
        readFile(files[index]).then(function() {
          readSequential(index + 1);
        }).catch(reject);
      }
    };

   readSequential(0); // Start!

  });
};

El código anterior funciona, pero no me gusta tener que recurrir para que las cosas ocurran secuencialmente. ¿Hay alguna manera más simple de que este código se pueda volver a escribir para que no tenga que usar mi extrañoreadSequential función?

Originalmente intenté usarlo Promise.all, pero eso provocó que todas las readFilellamadas tuvieran lugar simultáneamente, lo cual no es lo que quiero:

var readFiles = function(files) {
  return Promise.all(files.map(function(file) {
    return readFile(file);
  }));
};

Actualización 2017 : usaría una función asíncrona si el entorno lo admite:

async function readFiles(files) {
  for(const file of files) {
    await readFile(file);
  }
};

Si lo desea, puede aplazar la lectura de los archivos hasta que los necesite utilizando un generador asíncrono (si su entorno lo admite):

async function* readFiles(files) {
  for(const file of files) {
    yield await readFile(file);
  }
};

Actualización: Pensándolo bien, podría usar un bucle for en su lugar:

var readFiles = function(files) {
  var p = Promise.resolve(); // Q() in q

  files.forEach(file =>
      p = p.then(() => readFile(file)); 
  );
  return p;
};

O más compacto, con reducción:

var readFiles = function(files) {
  return files.reduce((p, file) => {
     return p.then(() => readFile(file));
  }, Promise.resolve()); // initial
};

En otras bibliotecas prometedoras (como when y Bluebird) tiene métodos de utilidad para esto.

Por ejemplo, Bluebird sería:

var Promise = require("bluebird");
var fs = Promise.promisifyAll(require("fs"));

var readAll = Promise.resolve(files).map(fs.readFileAsync,{concurrency: 1 });
// if the order matters, you can use Promise.each instead and omit concurrency param

readAll.then(function(allFileContents){
    // do stuff to read files.
});

Aunque realmente no hay razón para no usar async, aguarde hoy.

Así es como prefiero ejecutar tareas en serie.

function runSerial() {
    var that = this;
    // task1 is a function that returns a promise (and immediately starts executing)
    // task2 is a function that returns a promise (and immediately starts executing)
    return Promise.resolve()
        .then(function() {
            return that.task1();
        })
        .then(function() {
            return that.task2();
        })
        .then(function() {
            console.log(" ---- done ----");
        });
}

¿Qué pasa con los casos con más tareas? Como, 10?

function runSerial(tasks) {
  var result = Promise.resolve();
  tasks.forEach(task => {
    result = result.then(() => task());
  });
  return result;
}

Esta pregunta es antigua, pero vivimos en un mundo de ES6 y JavaScript funcional, así que veamos cómo podemos mejorar.

Debido a que las promesas se ejecutan de inmediato, no podemos simplemente crear una serie de promesas, todas se dispararían en paralelo.

En cambio, necesitamos crear una serie de funciones que devuelva una promesa. Cada función se ejecutará secuencialmente, lo que iniciará la promesa en su interior.

Podemos resolver esto de varias maneras, pero mi forma favorita es usar reduce.

Se vuelve un poco complicado usarlo reduceen combinación con las promesas, por lo que he dividido el revestimiento en algunas picaduras más pequeñas que se pueden digerir a continuación.

La esencia de esta función es usarla reducecomenzando con un valor inicial de Promise.resolve([]), o una promesa que contenga una matriz vacía.

Esta promesa se pasará al reducemétodo como promise. Esta es la clave para encadenar cada promesa en forma secuencial. La próxima promesa de ejecución es funcy cuando se thendispara, los resultados se concatenan y esa promesa se devuelve, ejecutando el reduceciclo con la siguiente función de promesa.

Una vez que se hayan ejecutado todas las promesas, la promesa devuelta contendrá una serie de todos los resultados de cada promesa.

Ejemplo ES6 (un revestimiento)

/*
 * serial executes Promises sequentially.
 * @param {funcs} An array of funcs that return promises.
 * @example
 * const urls = ['/url1', '/url2', '/url3']
 * serial(urls.map(url => () => $.ajax(url)))
 *     .then(console.log.bind(console))
 */
const serial = funcs =>
    funcs.reduce((promise, func) =>
        promise.then(result => func().then(Array.prototype.concat.bind(result))), Promise.resolve([]))

Ejemplo ES6 (desglosado)

// broken down to for easier understanding

const concat = list => Array.prototype.concat.bind(list)
const promiseConcat = f => x => f().then(concat(x))
const promiseReduce = (acc, x) => acc.then(promiseConcat(x))
/*
 * serial executes Promises sequentially.
 * @param {funcs} An array of funcs that return promises.
 * @example
 * const urls = ['/url1', '/url2', '/url3']
 * serial(urls.map(url => () => $.ajax(url)))
 *     .then(console.log.bind(console))
 */
const serial = funcs => funcs.reduce(promiseReduce, Promise.resolve([]))

Uso:

// first take your work
const urls = ['/url1', '/url2', '/url3', '/url4']

// next convert each item to a function that returns a promise
const funcs = urls.map(url => () => $.ajax(url))

// execute them serially
serial(funcs)
    .then(console.log.bind(console))

Para hacer esto simplemente en ES6:

function(files) {
  // Create a new empty promise (don't do that with real people ;)
  var sequence = Promise.resolve();

  // Loop over each file, and add on a promise to the
  // end of the 'sequence' promise.
  files.forEach(file => {

    // Chain one computation onto the sequence
    sequence = 
      sequence
        .then(() => performComputation(file))
        .then(result => doSomething(result)); 
        // Resolves for each file, one at a time.

  })

  // This will resolve after the entire chain is resolved
  return sequence;
}

Util simple para la promesa estándar de Node.js:

function sequence(tasks, fn) {
    return tasks.reduce((promise, task) => promise.then(() => fn(task)), Promise.resolve());
}

ACTUALIZAR

items-promise es un paquete NPM listo para usar que hace lo mismo.

Tuve que ejecutar muchas tareas secuenciales y usé estas respuestas para forjar una función que se encargaría de manejar cualquier tarea secuencial ...

function one_by_one(objects_array, iterator, callback) {
    var start_promise = objects_array.reduce(function (prom, object) {
        return prom.then(function () {
            return iterator(object);
        });
    }, Promise.resolve()); // initial
    if(callback){
        start_promise.then(callback);
    }else{
        return start_promise;
    }
}

La función toma 2 argumentos + 1 opcional. El primer argumento es la matriz en la que estaremos trabajando. El segundo argumento es la tarea en sí, una función que devuelve una promesa, la siguiente tarea se iniciará solo cuando esta promesa se resuelva. El tercer argumento es una devolución de llamada para ejecutarse cuando se hayan realizado todas las tareas. Si no se pasa la devolución de llamada, la función devuelve la promesa que creó para que podamos manejar el final.

Aquí hay un ejemplo de uso:

var filenames = ['1.jpg','2.jpg','3.jpg'];
var resize_task = function(filename){
    //return promise of async resizing with filename
};
one_by_one(filenames,resize_task );

Espero que ahorre algo de tiempo a alguien ...

La mejor solución que pude resolver fue con bluebirdpromesas. Simplemente puede hacer lo Promise.resolve(files).each(fs.readFileAsync);que garantiza que las promesas se resuelvan secuencialmente en orden.

Esta es una ligera variación de otra respuesta anterior. Usando promesas nativas:

function inSequence(tasks) {
    return tasks.reduce((p, task) => p.then(task), Promise.resolve())
}

Explicación

Si tienes estas tareas [t1, t2, t3] , entonces lo anterior es equivalente a Promise.resolve().then(t1).then(t2).then(t3). Es el comportamiento de reducir.

Cómo utilizar

Primero necesitas construir una lista de tareas! Una tarea es una función que no acepta argumentos. Si necesita pasar argumentos a su función, utilice bindu otros métodos para crear una tarea. Por ejemplo:

var tasks = files.map(file => processFile.bind(null, file))
inSequence(tasks).then(...)

Mi solución preferida:

function processArray(arr, fn) {
    return arr.reduce(
        (p, v) => p.then((a) => fn(v).then(r => a.concat([r]))),
        Promise.resolve([])
    );
}

No es fundamentalmente diferente de otros publicados aquí, pero:

• Aplica la función a los elementos en serie.
• Resuelve una variedad de resultados.
• No requiere asíncrono / espera (el soporte aún es bastante limitado, alrededor de 2017)
• Utiliza funciones de flecha; agradable y conciso

Ejemplo de uso:

const numbers = [0, 4, 20, 100];
const multiplyBy3 = (x) => new Promise(res => res(x * 3));

// Prints [ 0, 12, 60, 300 ]
processArray(numbers, multiplyBy3).then(console.log);

Probado en Chrome actual razonable (v59) y NodeJS (v8.1.2).

¡Úselo Array.prototype.reducey recuerde incluir sus promesas en una función, de lo contrario ya se estarán ejecutando!

// array of Promise providers

const providers = [
  function(){
     return Promise.resolve(1);
  },
  function(){
     return Promise.resolve(2);
  },
  function(){
     return Promise.resolve(3);
  }
]


const inSeries = function(providers){

  const seed = Promise.resolve(null); 

  return providers.reduce(function(a,b){
      return a.then(b);
  }, seed);
};

agradable y fácil ... debería poder reutilizar la misma semilla para el rendimiento, etc.

Es importante protegerse contra las matrices vacías o las matrices con solo 1 elemento cuando se utiliza reducir , por lo que esta técnica es su mejor opción:

   const providers = [
      function(v){
         return Promise.resolve(v+1);
      },
      function(v){
         return Promise.resolve(v+2);
      },
      function(v){
         return Promise.resolve(v+3);
      }
    ]

    const inSeries = function(providers, initialVal){

        if(providers.length < 1){
            return Promise.resolve(null)
        }

        return providers.reduce((a,b) => a.then(b), providers.shift()(initialVal));
    };

y luego lo llaman así:

inSeries(providers, 1).then(v => {
   console.log(v);  // 7
});

Creé este método simple en el objeto Promise:

Cree y agregue un método Promise.sequence al objeto Promise

Promise.sequence = function (chain) {
    var results = [];
    var entries = chain;
    if (entries.entries) entries = entries.entries();
    return new Promise(function (yes, no) {
        var next = function () {
            var entry = entries.next();
            if(entry.done) yes(results);
            else {
                results.push(entry.value[1]().then(next, function() { no(results); } ));
            }
        };
        next();
    });
};

Uso:

var todo = [];

todo.push(firstPromise);
if (someCriterium) todo.push(optionalPromise);
todo.push(lastPromise);

// Invoking them
Promise.sequence(todo)
    .then(function(results) {}, function(results) {});

Lo mejor de esta extensión del objeto Promise es que es coherente con el estilo de las promesas. Promise.all y Promise.sequence se invocan de la misma manera, pero tienen una semántica diferente.

Precaución

La ejecución secuencial de promesas no suele ser una muy buena forma de utilizarlas. Por lo general, es mejor usar Promise.all y dejar que el navegador ejecute el código lo más rápido posible. Sin embargo, existen casos de uso reales, por ejemplo, al escribir una aplicación móvil con javascript.

Puede usar esta función que se promete Lista de fábricas:

function executeSequentially(promiseFactories) {
    var result = Promise.resolve();
    promiseFactories.forEach(function (promiseFactory) {
        result = result.then(promiseFactory);
    });
    return result;
}

Promise Factory es simplemente una función simple que devuelve una Promesa:

function myPromiseFactory() {
    return somethingThatCreatesAPromise();
}

Funciona porque una fábrica de promesas no crea la promesa hasta que se le pide. Funciona de la misma manera que una función then; de hecho, ¡es lo mismo!

No desea operar sobre una serie de promesas en absoluto. Según la especificación Promesa, tan pronto como se crea una promesa, comienza a ejecutarse. Entonces, lo que realmente quieres es una variedad de fábricas prometedoras ...

Si desea obtener más información sobre Promesas, debe consultar este enlace: https://pouchdb.com/2015/05/18/we-have-a-problem-with-promises.html

Mi respuesta está basada en https://stackoverflow.com/a/31070150/7542429 .

Promise.series = function series(arrayOfPromises) {
    var results = [];
    return arrayOfPromises.reduce(function(seriesPromise, promise) {
      return seriesPromise.then(function() {
        return promise
        .then(function(result) {
          results.push(result);
        });
      });
    }, Promise.resolve())
    .then(function() {
      return results;
    });
  };

Esta solución devuelve los resultados como una matriz como Promise.all ().

Uso:

Promise.series([array of promises])
.then(function(results) { 
  // do stuff with results here
});

Realmente me gustó la respuesta de @ joelnet, pero para mí, ese estilo de codificación es un poco difícil de digerir, así que pasé un par de días tratando de descubrir cómo expresaría la misma solución de una manera más legible y esta es mi tomar, solo con una sintaxis diferente y algunos comentarios.

// first take your work
const urls = ['/url1', '/url2', '/url3', '/url4']

// next convert each item to a function that returns a promise
const functions = urls.map((url) => {
  // For every url we return a new function
  return () => {
    return new Promise((resolve) => {
      // random wait in milliseconds
      const randomWait = parseInt((Math.random() * 1000),10)
      console.log('waiting to resolve in ms', randomWait)
      setTimeout(()=>resolve({randomWait, url}),randomWait)
    })
  }
})


const promiseReduce = (acc, next) => {
  // we wait for the accumulator to resolve it's promise
  return acc.then((accResult) => {
    // and then we return a new promise that will become
    // the new value for the accumulator
    return next().then((nextResult) => {
      // that eventually will resolve to a new array containing
      // the value of the two promises
      return accResult.concat(nextResult)
    })
  })
};
// the accumulator will always be a promise that resolves to an array
const accumulator = Promise.resolve([])

// we call reduce with the reduce function and the accumulator initial value
functions.reduce(promiseReduce, accumulator)
  .then((result) => {
    // let's display the final value here
    console.log('=== The final result ===')
    console.log(result)
  })

Como Bergi notó, creo que la solución mejor y clara es usar BlueBird, cada uno, el código a continuación:

const BlueBird = require('bluebird');
BlueBird.each(files, fs.readFileAsync);

Primero, debe comprender que una promesa se ejecuta en el momento de la creación.
Entonces, por ejemplo, si tiene un código:

["a","b","c"].map(x => returnsPromise(x))

Necesitas cambiarlo a:

["a","b","c"].map(x => () => returnsPromise(x))

Entonces necesitamos encadenar las promesas secuencialmente:

["a", "b", "c"].map(x => () => returnsPromise(x))
    .reduce(
        (before, after) => before.then(_ => after()),
        Promise.resolve()
    )

ejecutando after(), se asegurará de que la promesa se cree (y ejecute) solo cuando llegue el momento.

Yo uso el siguiente código para extender el objeto Promise. Maneja el rechazo de las promesas y devuelve una serie de resultados.

Código

/*
    Runs tasks in sequence and resolves a promise upon finish

    tasks: an array of functions that return a promise upon call.
    parameters: an array of arrays corresponding to the parameters to be passed on each function call.
    context: Object to use as context to call each function. (The 'this' keyword that may be used inside the function definition)
*/
Promise.sequence = function(tasks, parameters = [], context = null) {
    return new Promise((resolve, reject)=>{

        var nextTask = tasks.splice(0,1)[0].apply(context, parameters[0]); //Dequeue and call the first task
        var output = new Array(tasks.length + 1);
        var errorFlag = false;

        tasks.forEach((task, index) => {
            nextTask = nextTask.then(r => {
                output[index] = r;
                return task.apply(context, parameters[index+1]);
            }, e=>{
                output[index] = e;
                errorFlag = true;
                return task.apply(context, parameters[index+1]);
            });
        });

        // Last task
        nextTask.then(r=>{
            output[output.length - 1] = r;
            if (errorFlag) reject(output); else resolve(output);
        })
        .catch(e=>{
            output[output.length - 1] = e;
            reject(output);
        });
    });
};

Ejemplo

function functionThatReturnsAPromise(n) {
    return new Promise((resolve, reject)=>{
        //Emulating real life delays, like a web request
        setTimeout(()=>{
            resolve(n);
        }, 1000);
    });
}

var arrayOfArguments = [['a'],['b'],['c'],['d']];
var arrayOfFunctions = (new Array(4)).fill(functionThatReturnsAPromise);


Promise.sequence(arrayOfFunctions, arrayOfArguments)
.then(console.log)
.catch(console.error);

Si lo desea, puede usar reducir para hacer una promesa secuencial, por ejemplo:

[2,3,4,5,6,7,8,9].reduce((promises, page) => {
    return promises.then((page) => {
        console.log(page);
        return Promise.resolve(page+1);
    });
  }, Promise.resolve(1));

siempre funcionará en secuencia.

Usando ES moderno:

const series = async (tasks) => {
  const results = [];

  for (const task of tasks) {
    const result = await task;

    results.push(result);
  }

  return results;
};

//...

const readFiles = await series(files.map(readFile));

Con Async / Await (si tiene el soporte de ES7)

function downloadFile(fileUrl) { ... } // This function return a Promise

async function main()
{
  var filesList = [...];

  for (const file of filesList) {
    await downloadFile(file);
  }
}

(debes usar forloop, y noforEach porque async / await tenga problemas para ejecutarse en cada bucle)

Sin Async / Await (usando Promise)

function downloadFile(fileUrl) { ... } // This function return a Promise

function downloadRecursion(filesList, index)
{
  index = index || 0;
  if (index < filesList.length)
  {
    downloadFile(filesList[index]).then(function()
    {
      index++;
      downloadRecursion(filesList, index); // self invocation - recursion!
    });
  }
  else
  {
    return Promise.resolve();
  }
}

function main()
{
  var filesList = [...];
  downloadRecursion(filesList);
}

Sobre la base del título de la pregunta, "¿Resolver promesas una tras otra (es decir, en secuencia)?", Podríamos entender que el OP está más interesado en el manejo secuencial de las promesas de liquidación que las llamadas secuenciales per se .

Esta respuesta se ofrece:

• para demostrar que las llamadas secuenciales no son necesarias para el manejo secuencial de las respuestas.
• para exponer patrones alternativos viables a los visitantes de esta página, incluido el OP si aún está interesado más de un año después.
• a pesar de la afirmación del OP de que no quiere hacer llamadas al mismo tiempo, lo cual puede ser realmente el caso, pero igualmente puede ser una suposición basada en el deseo de un manejo secuencial de las respuestas como lo implica el título.

Si realmente no se desean llamadas concurrentes, vea la respuesta de Benjamin Gruenbaum que cubre las llamadas secuenciales (etc.) de manera integral.

Sin embargo, si está interesado (para mejorar el rendimiento) en patrones que permiten llamadas simultáneas seguidas de un manejo secuencial de las respuestas, siga leyendo.

Es tentador pensar que tiene que usar Promise.all(arr.map(fn)).then(fn)(como lo he hecho muchas veces) o un azúcar elegante de Promise lib (especialmente Bluebird), sin embargo (con crédito a este artículo ) un arr.map(fn).reduce(fn)patrón hará el trabajo, con las ventajas de que:

• funciona con cualquier lib de promesa, incluso versiones precompatibles de jQuery, solo .then() se usa.
• ofrece la flexibilidad de omitir el error o detener el error, lo que quieras con un mod de una línea.

Aquí está, escrito para Q.

var readFiles = function(files) {
    return files.map(readFile) //Make calls in parallel.
    .reduce(function(sequence, filePromise) {
        return sequence.then(function() {
            return filePromise;
        }).then(function(file) {
            //Do stuff with file ... in the correct sequence!
        }, function(error) {
            console.log(error); //optional
            return sequence;//skip-over-error. To stop-on-error, `return error` (jQuery), or `throw  error` (Promises/A+).
        });
    }, Q()).then(function() {
        // all done.
    });
};

Nota: solo ese fragmento, Q() es específico de Q. Para jQuery, debe asegurarse de que readFile () devuelva una promesa de jQuery. Con las bibliotecas A +, las promesas extranjeras se asimilarán.

La clave aquí es la sequencepromesa de la reducción , que secuencia el manejo delreadFile promesas pero no su creación.

Y una vez que haya absorbido eso, ¡tal vez sea un poco alucinante cuando se dé cuenta de que el .map()escenario no es realmente necesario! Todo el trabajo, llamadas paralelas más manejo en serie en el orden correcto, se puede lograr reduce()solo, más la ventaja adicional de una mayor flexibilidad para:

• Convierta de llamadas asíncronas paralelas a llamadas asíncronas en serie simplemente moviendo una línea, potencialmente útil durante el desarrollo.

Aquí está, para Qotra vez.

var readFiles = function(files) {
    return files.reduce(function(sequence, f) {
        var filePromise = readFile(f);//Make calls in parallel. To call sequentially, move this line down one.
        return sequence.then(function() {
            return filePromise;
        }).then(function(file) {
            //Do stuff with file ... in the correct sequence!
        }, function(error) {
            console.log(error); //optional
            return sequence;//Skip over any errors. To stop-on-error, `return error` (jQuery), or `throw  error` (Promises/A+).
        });
    }, Q()).then(function() {
        // all done.
    });
};

Ese es el patrón básico. Si también quisiera entregar datos (por ejemplo, los archivos o alguna transformación de ellos) a la persona que llama, necesitaría una variante leve.

Su enfoque no es malo, pero tiene dos problemas: se traga los errores y emplea el antipatrón de construcción de promesa explícita.

Puede resolver estos dos problemas y hacer que el código sea más limpio, mientras sigue empleando la misma estrategia general:

var Q = require("q");

var readFile = function(file) {
  ... // Returns a promise.
};

var readFiles = function(files) {
  var readSequential = function(index) {
    if (index < files.length) {
      return readFile(files[index]).then(function() {
        return readSequential(index + 1);
      });
    }
  };

  // using Promise.resolve() here in case files.length is 0
  return Promise.resolve(readSequential(0)); // Start!
};

Si alguien más necesita una forma garantizada de una forma ESTRICTAMENTE secuencial de resolver Promesas al realizar operaciones CRUD, también puede usar el siguiente código como base.

Siempre que agregue 'return' antes de llamar a cada función, describiendo una Promesa, y use este ejemplo como base, la siguiente llamada a la función .then () comenzará CONSISTENTEMENTE después de completar la anterior:

getRidOfOlderShoutsPromise = () => {
    return readShoutsPromise('BEFORE')
    .then(() => {
        return deleteOlderShoutsPromise();
    })
    .then(() => {
        return readShoutsPromise('AFTER')
    })
    .catch(err => console.log(err.message));
}

deleteOlderShoutsPromise = () => {
    return new Promise ( (resolve, reject) => {
        console.log("in deleteOlderShouts");
        let d = new Date();
        let TwoMinuteAgo = d - 1000 * 90 ;
        All_Shouts.deleteMany({ dateTime: {$lt: TwoMinuteAgo}}, function(err) {
            if (err) reject();
            console.log("DELETED OLDs at "+d);
            resolve();        
        });
    });
}

readShoutsPromise = (tex) => {
    return new Promise( (resolve, reject) => {
        console.log("in readShoutsPromise -"+tex);
        All_Shouts
        .find({})
        .sort([['dateTime', 'ascending']])
        .exec(function (err, data){
            if (err) reject();
            let d = new Date();
            console.log("shouts "+tex+" delete PROMISE = "+data.length +"; date ="+d);
            resolve(data);
        });    
    });
}

El método push y pop de matriz se puede usar para la secuencia de promesas. También puede impulsar nuevas promesas cuando necesite datos adicionales. Este es el código que usaré en el cargador React Infinite para cargar la secuencia de páginas.

var promises = [Promise.resolve()];

function methodThatReturnsAPromise(page) {
	return new Promise((resolve, reject) => {
		setTimeout(() => {
			console.log(`Resolve-${page}! ${new Date()} `);
			resolve();
		}, 1000);
	});
}

function pushPromise(page) {
	promises.push(promises.pop().then(function () {
		return methodThatReturnsAPromise(page)
	}));
}

pushPromise(1);
pushPromise(2);
pushPromise(3);

La mayoría de las respuestas no incluyen los resultados de TODAS las promesas individualmente, por lo que en caso de que alguien esté buscando este comportamiento en particular, esta es una posible solución mediante la recursividad.

Sigue el estilo de Promise.all:

• Devuelve la matriz de resultados en la .then()devolución de llamada.

• Si alguna promesa falla, se devuelve inmediatamente en la .catch()devolución de llamada.

const promiseEach = (arrayOfTasks) => {
  let results = []
  return new Promise((resolve, reject) => {
    const resolveNext = (arrayOfTasks) => {
      // If all tasks are already resolved, return the final array of results
      if (arrayOfTasks.length === 0) return resolve(results)

      // Extract first promise and solve it
      const first = arrayOfTasks.shift()

      first().then((res) => {
        results.push(res)
        resolveNext(arrayOfTasks)
      }).catch((err) => {
        reject(err)
      })
    }
    resolveNext(arrayOfTasks)
  })
}

// Lets try it 😎

const promise = (time, shouldThrowError) => new Promise((resolve, reject) => {
  const timeInMs = time * 1000
  setTimeout(()=>{
    console.log(`Waited ${time} secs`)
    if (shouldThrowError) reject(new Error('Promise failed'))
    resolve(time)
  }, timeInMs)
})

const tasks = [() => promise(1), () => promise(2)]

promiseEach(tasks)
  .then((res) => {
    console.log(res) // [1, 2]
  })
  // Oops some promise failed
  .catch((error) => {
    console.log(error)
  })

Nota sobre la tasksdeclaración de matriz :

En este caso no es posible usar la siguiente notación como Promise.allusaría:

const tasks = [promise(1), promise(2)]

Y tenemos que usar:

const tasks = [() => promise(1), () => promise(2)]

La razón es que JavaScript comienza a ejecutar la promesa inmediatamente después de su declaración. Si usamos métodos como Promise.all, solo verifica que el estado de todos ellos sea fulfilledo rejected, pero no inicia la exención en sí. Usando () => promise()detenemos la ejecución hasta que se llame.

(function() {
  function sleep(ms) {
    return new Promise(function(resolve) {
      setTimeout(function() {
        return resolve();
      }, ms);
    });
  }

  function serial(arr, index, results) {
    if (index == arr.length) {
      return Promise.resolve(results);
    }
    return new Promise(function(resolve, reject) {
      if (!index) {
        index = 0;
        results = [];
      }
      return arr[index]()
        .then(function(d) {
          return resolve(d);
        })
        .catch(function(err) {
          return reject(err);
        });
    })
      .then(function(result) {
        console.log("here");
        results.push(result);
        return serial(arr, index + 1, results);
      })
      .catch(function(err) {
        throw err;
      });
  }

  const a = [5000, 5000, 5000];

  serial(a.map(x => () => sleep(x)));
})();

Aquí la clave es cómo llamar a la función dormir. Debe pasar una serie de funciones que en sí devuelve una promesa en lugar de una serie de promesas.

Esto es para ampliar cómo procesar una secuencia de promesas de una manera más genérica, admitiendo secuencias dinámicas / infinitas, basadas en la implementación de secuencia spex :

var $q = require("q");
var spex = require('spex')($q);

var files = []; // any dynamic source of files;

var readFile = function (file) {
    // returns a promise;
};

function source(index) {
    if (index < files.length) {
        return readFile(files[index]);
    }
}

function dest(index, data) {
    // data = resolved data from readFile;
}

spex.sequence(source, dest)
    .then(function (data) {
        // finished the sequence;
    })
    .catch(function (error) {
        // error;
    });

No solo esta solución funcionará con secuencias de cualquier tamaño, sino que puede agregarle fácilmente aceleración de datos y equilibrio de carga .