javascript - nodejs - promises js

¿Cuál es la mejor manera de pasar los valores de promesa resueltos a una cadena final de "entonces"

Question

Esta pregunta ya tiene una respuesta aquí:

• ¿Cómo accedo a los resultados de promesas anteriores en una cadena .then ()? 15 respuestas

Estoy tratando de entender mis promesas, usando el módulo Q en node.js, pero tengo un pequeño problema.

En este ejemplo:

ModelA.create(/* params */)
.then(function(modelA){
    return ModelB.create(/* params */);
})
.then(function(modelB){
    return ModelC.create(/* params */);
})
.then(function(modelC){

    // need to do stuff with modelA, modelB and modelC

})
.fail(/*do failure stuff*/);

El método .create devuelve una promesa luego en cada .then (), según lo esperado, se obtiene el valor resuelto de la promesa.

Sin embargo, en la final .then () necesito tener los 3 valores de promesa resueltos previamente.

Cuál sería la mejor forma de hacer esto?

Answer 1

Estas son algunas de tus muchas opciones:

Detrás de la puerta 1, use reducir para acumular los resultados en serie.

var models = [];
[
    function () {
        return ModelA.create(/*...*/);
    },
    function () {
        return ModelB.create(/*...*/);
    },
    function () {
        return ModelC.create(/*...*/);
    }
].reduce(function (ready, makeModel) {
    return ready.then(function () {
        return makeModel().then(function (model) {
            models.push(model);
        });
    });
}, Q())
.catch(function (error) {
    // handle errors
});

Detrás de la puerta 2, empaque los modelos acumulados en una matriz y desempaque con la extensión.

Q.try(function () {
    return ModelA.create(/* params */)
})
.then(function(modelA){
    return [modelA, ModelB.create(/* params */)];
})
.spread(function(modelA, modelB){
    return [modelA, modelB, ModelC.create(/* params */)];
})
.spread(function(modelA, modelB, modelC){
    // need to do stuff with modelA, modelB and modelC
})
.catch(/*do failure stuff*/);

Detrás de la puerta 3, capture los resultados en el ámbito principal:

var models [];
ModelA.create(/* params */)
.then(function(modelA){
    models.push(modelA);
    return ModelB.create(/* params */);
})
.then(function(modelB){
    models.push(modelB);
    return ModelC.create(/* params */);
})
.then(function(modelC){
    models.push(modelC);

    // need to do stuff with models

})
.catch(function (error) {
    // handle error
});

Answer 2

La biblioteca de promesas de Bluebird proporciona otra solución para esto a través de .bind() .

Se parece a esto:

ModelA.create(/* params */).bind({})
.then(function (modelA) {
    this.modelA = modelA;
    return ModelB.create(/* params */);
})
.then(function (modelB) {
    this.modelB = modelB;
    return ModelC.create(/* params */);
})
.then(function (modelC) {
    // you have access to this.modelA, this.modelB and modelC;
});

Hay mucha información interesante sobre este método en la documentation .

Answer 3

Probablemente no necesite esperar hasta que se cree el modelo A para crear el modelo B y así sucesivamente.
Si esto es cierto, entonces puedes hacer lo siguiente:

var promises = [
  ModelA.create(...),
  ModelB.create(...),
  ModelC.create(...)
);

Q.all( promises ).spread(function( modelA, modelB, modelC ) {
  // Do things with them!
}).fail(function() {
  // Oh noes :(
});

Lo que esto hace es:

• Cree una variedad de promesas, con una promesa para cada modelo que necesite;
• Ejecutar las 3 promesas en paralelo;
• Ejecute una función pasada en spread() cuando se cumplan las 3 promesas. Los argumentos son los valores resueltos para cada promesa, en el orden de declaración.

Espero que te ayude :)