Promise.all (). Luego () resolver?

Usando Node 4.x. Cuando tiene una, Promise.all(promises).then()¿cuál es la forma correcta de resolver los datos y pasarlos a la siguiente .then()?

Quiero hacer algo como esto:

Promise.all(promises).then(function(data){
  // Do something with the data here
}).then(function(data){
  // Do more stuff here
});

Pero no estoy seguro de cómo llevar los datos al 2do .then(). No puedo usar resolve(...)en el primero .then(). Descubrí que puedo hacer esto:

return Promise.all(promises).then(function(data){
  // Do something with the data here
  return data;
}).then(function(data){
  // Do more stuff here
});

Pero esa no parece la forma correcta de hacerlo ... ¿Cuál es el enfoque correcto para esto?

Pero esa no parece la forma correcta de hacerlo ...

De hecho, esa es la forma correcta de hacerlo (o al menos una forma correcta de hacerlo). Este es un aspecto clave de las promesas, son una canalización y los datos pueden ser manipulados por los diversos controladores en la canalización.

Ejemplo:

const promises = [
  new Promise(resolve => setTimeout(resolve, 0, 1)),
  new Promise(resolve => setTimeout(resolve, 0, 2))
];
Promise.all(promises)
  .then(data => {
    console.log("First handler", data);
    return data.map(entry => entry * 10);
  })
  .then(data => {
    console.log("Second handler", data);
  });

(El catchcontrolador se omite por brevedad. En el código de producción, siempre propague la promesa o controle el rechazo).

El resultado que vemos de eso es:

Primer manipulador [1,2]
Segunda mano [10,20]

... porque el primer controlador obtiene la resolución de las dos promesas ( 1y 2) como una matriz, y luego crea una nueva matriz con cada una de ellas multiplicada por 10 y la devuelve. El segundo controlador obtiene lo que devolvió el primer controlador.

Si el trabajo adicional que está haciendo es sincrónico, también puede ponerlo en el primer controlador:

Ejemplo:

const promises = [
  new Promise(resolve => setTimeout(resolve, 0, 1)),
  new Promise(resolve => setTimeout(resolve, 0, 2))
];
Promise.all(promises)
  .then(data => {
    console.log("Initial data", data);
    data = data.map(entry => entry * 10);
    console.log("Updated data", data);
    return data;
  });

... pero si es asincrónico, no querrá hacer eso, ya que termina anidando, y la anidación puede salirse de control rápidamente.

Hoy, NodeJS admite una nueva async/awaitsintaxis. Esta es una sintaxis fácil y hace la vida mucho más fácil.

async function process(promises) { // must be an async function
    let x = await Promise.all(promises);  // now x will be an array
    x = x.map( tmp => tmp * 10);              // proccessing the data.
}

const promises = [
   new Promise(resolve => setTimeout(resolve, 0, 1)),
   new Promise(resolve => setTimeout(resolve, 0, 2))
];

process(promises)

Aprende más:

• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function

Su return dataenfoque es correcto, ese es un ejemplo de encadenamiento de promesas . Si devuelve una promesa de su .then()devolución de llamada, JavaScript resolverá esa promesa y pasará los datos a la siguiente then()devolución de llamada.

Solo tenga cuidado y asegúrese de manejar los errores con .catch(). Promise.all()rechaza tan pronto como una de las promesas de la matriz rechaza .