javascript - Cómo estructurar promesas anidadas

node.js promise

Question

Tengo una situación en la que creo que la única opción para mí es anidar algunas promesas entre sí. Tengo una promesa que debe realizarse y un método que hace algo hasta que se complete esa promesa. Algo como esto:

let promise = new Promise((resolve, reject) => {

  // Do some stuff

});

doSomethingUntilPromiseisDone(promise);

Sin embargo, dentro de mi Promesa, necesito ejecutar otro método que devuelva otra Promesa:

let promise = new Promise((resolve, reject) => {

  fetchValue(url)
    .then((value) => {

      // Do something here

    }).catch((err) => {
      console.error(err);
    });

});

doSomethingUntilPromiseisDone(promise);

Pero ahora, en la fetchValue método fetchValue , tengo otro método que necesito ejecutar, adivina qué, devuelve otra Promesa:

let promise = new Promise((resolve, reject) => {

  fetchValue(url)
    .then((value) => {

      saveToCache(value)
        .then((success) => {

          console.log(''success!!'');
          resolve(''success'');

        });

    }).catch((err) => {
      console.error(err);
    });

});

doSomethingUntilPromiseisDone(promise);

Entonces, al final, tengo una promesa, dentro de una promesa, dentro de una promesa. ¿Hay alguna forma de estructurar esto mejor para que sea más sencillo? Parece que anidarlos entre sí es contrario al enfoque de encadenamiento previsto de Promise.

Answer 1

Cada función llamará a la siguiente con el resultado del método anterior.

var promises = [1,2,3].map((guid)=>{
    return (param)=> {
      console.log("param", param);
      var id = guid;
      return new Promise(resolve => {
        // resolve in a random amount of time
        setTimeout(function () {
          resolve(id);
        }, (Math.random() * 1.5 | 0) * 1000);
      });
    }
}).reduce(function (acc, curr, index) {
  return acc.then(function (res) {
    return curr(res[index-1]).then(function (result) {
      console.log("result", result);
      res.push(result);
      return res;
    });
  });
}, Promise.resolve([]));
promises.then(console.log);

Answer 2

Utilice .then()

let doStuff = (resolve, reject) => {/* resolve() or reject() */};
let promise = new Promise(doStuff);
doSomethingUntilPromiseisDone(
  promise 
  .then(value => fetchValue(url))
  .then(value => value.blob())
  .then(saveToCache)
)
.then(success => console.log("success!!"))
.catch(err => console.error(err))

Answer 3

puede usar el generator para aplanar sus promesas anidadas ( Bluebird.couroutine o Generators )

//Bluebird.couroutine
const generator = Promise.coroutine(function*() {
  try {
     const value = yield fetchValue(url);
     const success = yield saveToCache(value);
     console.log(''success:'', success);
  } catch(e) {
     console.error(err);
  }    
}));

generator();