Javascript NodeJS我的SQL查询与链承诺

我有3个函数，我想一步一步地调用这个函数，例如，当我调用firs函数并得到结果时，我必须调用第二个函数并传递第一次调用返回的参数。在完成第二次调用之后，我必须调用第三个函数并传递第二个函数返回的参数

#1：

#2：

#3：

我想反复浏览每个类别的每个房间

     getCategory(branch_id).then(firstRecords => {
        let promises = firstRecords.map(function (record) {
            return getRoom(branch_id, record.id)
                .then(roomData => {
                    var res = Object.assign({}, record, { room: roomData });
                    return res;
                })
        });
        return Promise.all(promises);
//HERE i have data that is placed above.
    }).then(secondRecords => {
        let promises = secondRecords.map(function (category) {
            return category.room;
        }).map(function (rooms) {
            console.log('SECOND', rooms);
            return rooms;
        }).map(function (reservation) {
            console.log('THERD', reservation);
            return reservation;
        })
        return Promise.all(promises);
    }).then(reservation => {
        console.log("Reservation", reservation);
    })

更新#2最终解决方案在这里

getCategory(branch_id) .then( categories => {

  let roomPromises = categories.map( category => {
    return getRoom(branch_id, category.id)
    .then( rooms => Object.assign({}, category, { rooms }) )   });

  return Promise.all(roomPromises) }) .then( category_rooms => {

  let finalPromise = category_rooms.map( category => {

    let reservationPromises = category.rooms.map( room => {
      return getReservationL(room.id, start_date, end_date)
      .then( reservations => Object.assign({}, room, { reservations }) )
    })

    return Promise.all(reservationPromises)
    .then( room_reservations => {
      return Object.assign({}, category, { rooms: room_reservations })
    });   })

  // const flattenPromise = finalPromise.reduce( (a, b) => a.concat(b), []);   // return Promise.all(flattenPromise);
     return Promise.all(finalPromise) }) .then( data => console.log('final: ', data) )

---

您可以使用

.then

解析一个承诺，并可以链接

then

以同步方式解析多个承诺

也许这将解决您的用例

getCategory()
.then( firstRecords => {

  console.log('firstRecords: ', firstRecords);

  let promises = firstRecords.map( record => getRoom(record) );
  return Promise.all(promises);
})
.then( secondRecords => {

  console.log('secondRecords: ', secondRecords);

  let promises = secondRecords.map( record => getReservationL(record) );
  return Promise.all(promises);
})
.then( thirdRecords => {

  console.log('thirdRecords: ', thirdRecords);
})

参考资料：

然后方法返回一个允许方法链接的承诺

如果作为处理程序传递给的函数随后返回一个承诺，那么将向方法链中的后续对象公开一个等价的承诺

引用：

方法返回一个承诺，当iterable参数中的所有承诺都已解析或iterable参数不包含承诺时，该承诺将解析。它拒绝的理由是第一个拒绝的承诺

更新#1

Promise.all

只接受Promise数组，而不接受键上带有Promise的对象

# wrong
Promise.all([
    { key: Promise.resolve(1) },
    { key: Promise.resolve(2) },
    { key: Promise.resolve(3) },
])

# right
Promise.all([ 
    Promise.resolve(1), 
    Promise.resolve(2), 
    Promise.resolve(3) 
])

你可以这样做来达到你在评论中提到的目的

getCategory(branch_id)
.then( firstRecords => {

  console.log('firstRecords: ', firstRecords);

  let promises = firstRecords.map( record => {
    return getRoom(branch_id, record.id)
    .then( roomData => Object.assign({}, record, { room : roomData }) )
  });
  
  return Promise.all(promises)
  
})

如果要附加第一个承诺和第二个承诺的数据，则只在一个位置解析承诺以访问这两个承诺的数据

更新#2 正如您在评论中提到的，此代码可能会对您有所帮助

getCategory(branch_id)
.then( categories => {

  let roomPromises = categories.map( category => {
    return getRoom(branch_id, category.id)
    .then( rooms => Object.assign({}, category, { rooms }) )
  });

  return Promise.all(roomPromises)

})
.then( category_rooms => {

  let finalPromise = category_rooms.map( category => {
    
    let reservationPromises = category.rooms.map( room => {
      return getReservationL(room.id, start_date, end_date)
      .then( reservations => Object.assign({}, room, { reservations }) )
    })

    return Promise.all(reservationPromises)
    .then( room_reservations => {
      return Object.assign({}, category, { rooms: room_reservations })
    });
  })
  
  return Promise.all(finalPromise)
})
.then( data => console.log(data) )

---

由于您的逻辑包含大量用于数据选择和转换的

循环

语句，因此您需要将其重构为如下内容：

getCategory(brandId)
    .then(addRoomData)
    .then(addReservationData)
    .then(handleFinalData)
    .catch(handleError);

对于

addRoomData

和

addReservationData

函数，您可能需要使用

---

如果您想以更可读的方式编写代码，请考虑使用.< /p> ，我认为使用<强> > asy.瀑布> /强>函数> <强> < />强>模块是比较优化的方法。

---

我有以下代码：getCategory（branch_id）.then（firstRecords=>{console.log（'firstRecords:'，firstRecords）；//record=>getRoom（branch_id，record.id）let promises=firstRecords.map（function（record）{var roomData=getRoom（branch_id，record.id）；record.room=roomData；return record；}）；return Promise.all（promises）；}）我正在获取空间：{state:'pending'}}有什么想法吗？这个方法获取promises getRoom（branch_id，record.id）；也许我有{状态：'待定'}。如何解决这个问题？在第二次迭代后，我得到了以下对象：[{“id”：64，“name”：“VIP”，“price”：116.5，“currency”：“USD”，“room”：[{“id”：44，“room_no”：“101”，“name”：“A”，“price”：100，“currency”：“EUR”}，{“id”：274，“room_no”：“505”，“name”：“a”，“price”：1，“c\r\nUrency”：“GEL”}，…}现在我想迭代每个类别的每个roomsgetCategory（branch_id）。然后（firstRecords=>{let promises=firstRecords.map（函数（记录）{return getRoom（branch_id，record.id）。然后（roomData=>{var res=Object.assign（{}，record，{room:roomData}）；roomData.map（函数（）{return getReservationL（roomData.id，start_date，end_date）。然后（reservationData=>{console.log（“reservationData”，reservationData）；return Object.assign（{}，record，{room:roomData}）；}）}）；这是迭代ower分类房间的正确代码吗？返回承诺。所有（承诺）；}）非常感谢你真的帮助了我。

getCategory()
.then( firstRecords => {

  console.log('firstRecords: ', firstRecords);

  let promises = firstRecords.map( record => getRoom(record) );
  return Promise.all(promises);
})
.then( secondRecords => {

  console.log('secondRecords: ', secondRecords);

  let promises = secondRecords.map( record => getReservationL(record) );
  return Promise.all(promises);
})
.then( thirdRecords => {

  console.log('thirdRecords: ', thirdRecords);
})

Promise.all([ { key: 1 }, Promise.resolve(3), 1, true ])
.then( results => {
    results[0]; // { key: 1 }
    results[1]; // 3
    results[2]; // 1
    results[3]; // true
})

# wrong
Promise.all([
    { key: Promise.resolve(1) },
    { key: Promise.resolve(2) },
    { key: Promise.resolve(3) },
])

# right
Promise.all([ 
    Promise.resolve(1), 
    Promise.resolve(2), 
    Promise.resolve(3) 
])

getCategory(branch_id)
.then( firstRecords => {

  console.log('firstRecords: ', firstRecords);

  let promises = firstRecords.map( record => {
    return getRoom(branch_id, record.id)
    .then( roomData => Object.assign({}, record, { room : roomData }) )
  });
  
  return Promise.all(promises)
  
})

getCategory(branch_id)
.then( categories => {

  let roomPromises = categories.map( category => {
    return getRoom(branch_id, category.id)
    .then( rooms => Object.assign({}, category, { rooms }) )
  });

  return Promise.all(roomPromises)

})
.then( category_rooms => {

  let finalPromise = category_rooms.map( category => {
    
    let reservationPromises = category.rooms.map( room => {
      return getReservationL(room.id, start_date, end_date)
      .then( reservations => Object.assign({}, room, { reservations }) )
    })

    return Promise.all(reservationPromises)
    .then( room_reservations => {
      return Object.assign({}, category, { rooms: room_reservations })
    });
  })
  
  return Promise.all(finalPromise)
})
.then( data => console.log(data) )

getCategory(brandId)
    .then(addRoomData)
    .then(addReservationData)
    .then(handleFinalData)
    .catch(handleError);

async.waterfall([
function(callback) {
    getSomething(options, function (err, result) {
        if (err) {
            callback(new Error("failed getting something:" + err.message));
            // we should return here
        }
        // since we did not return, this callback still will be called and
        // `processData` will be called twice
        callback(null, result);
    });
},
function(data, callback){
  //do something
}
], function(err,results){
  //get final results
});