javascript - Secuencia de promesas de arreglo dinámico

Estoy obteniendo un arreglo dinámico (el número de promesas puede cambiar en cada ejecución) de promesas. Ahora quiero que después de cada resolución o rechazo se maneje la promesa devuelta antes de que el arreglo de promesas haya terminado.

Intento con Promise.all pero continúa después de que se han completado todas las promesas.

si el arreglo (de promesas) no fuera dinámico podría simplemente usar algo como esto, pero no sé cuántas promesas tengo en el arreglo y quiero, después de que cada promesa se cumpla o ... proceder con su respuesta y no esperar hasta que todas las promesas estén hechas

firstMethod()
   .then(secondMethod)
   .then(thirdMethod);

Estamos usando Q ...

¿Es posible?

Actualización (ejemplo)

Digamos que tengo el arreglo de promesas

[promise1,promise2,promise3, promiseN]

Ahora quiero que, cuando promise1 termine de procesarse, se maneje con then y no esperar a que todas las promesas se hayan terminado.

El mayor problema aquí es que el array puede tener N promesas y no sé en tiempo de ejecución cuántas promesas voy a obtener hasta que tenga este array por lo tanto, no puedo usar simplemente then

Actualización 2 (para aclarar un poco más :-) ) La parte complicada...

Si sé el tamaño del arreglo de antemano, puedo usar simplemente entonces, 5 entradas en el arreglo 5 cadenas con entonces, pero aquí la parte complicada es que no sé de antemano cuántas promesas tendré en el arreglo de promesas...

Respuesta #1

Si el objetivo es encadenar cada promesa con el mismo then pero sin esperar a que todas las promesas se completen, esto es solo un bucle:

for (const promise of promiseArray) {
  promise.then(...)
}

Si los resultados de las promesas deben ser unidos al final, el arreglo puede ser procesado adicionalmente por all:

Promise.all(promiseArray.map(promise => promise.then(...)))
.then(...)

Nota que el comportamiento para all se aplica aquí. Si hay un rechazo no capturado en el array de promesas, solo se capturará el primer rechazo.

Esto es cierto para la mayoría de las implementaciones de promesas. Puede haber métodos Q que permitan hacer esto más fácilmente.

Respuesta #2

puedes usar Promise.race()

El método Promise.race(iterable) devuelve una promesa que se resuelve o se rechaza tan pronto como una de las promesas en el iterable se resuelve o se rechaza, con el valor o la razón de esa promesa.

var p1 = new Promise(function(resolve, reject) { 
    setTimeout(resolve, 500, 'one'); 
});
var p2 = new Promise(function(resolve, reject) { 
    setTimeout(resolve, 100, 'two'); 
});

Promise.race([p1, p2]).then(function(value) {
  console.log(value); // "two"
  // Both resolve, but p2 is faster
});