僅在諾言解決時返回地圖

Question

我正在使用loadash映射功能來進行數據的結構化。 數據返回一組ID，我需要查詢這些ID並將結果添加到地圖中，然后返回，但是稍后返回數據，並且我的函數首先返回。 如何使地圖返回等待然后返回功能。

let result = _.chain(value)
        .groupBy('pubId')
        .pairs()
        .map(function(currentItem) {
          let item =  _.object(_.zip(['ID', 'targetting'], currentItem));
          propsToBeDeleted.forEach(function(prop) {
            item.targetting.forEach(d => {
              item.publishername = d.RTB.name;
              item.type = d.type;
              delete d[prop];
            });
          });
          item.targetting.map(d => {
            if (d.type == 15) {
              d.name = Object.keys(JSON.parse(d.value));
              d.value = Object.values(JSON.parse(d.value))[0];
              item.dspIds = [];
            }
            if (d.type == 16) {
              let value = JSON.parse(d.value);
              d.name = Object.keys(JSON.parse(d.value)).filter(d => d != 'profileId');
              d.value = value;
              item.dspIds = d.value.profileId;
              dspAccount.find({where: {id: 139}}, (err, data) => {
                // async call wait here to get data and attach to item 
                 item.x = data ;
              });
              delete d.value.profileId;
              d.value = JSON.stringify(d.value);
            }
          });
          return item;
        })
        .value();

我也嘗試過使用諾言

promises.push(new Promise((resolve, reject) => {
        if (data.id) {
          XX.upsertWithWhere({id: data.id}, payload, (err, data) => {
            if (err) {
              return reject(err);
            }
            return resolve(data);
          });
        }
      }));
    });
    Promise.all(promises).then((data) => {
      callback(null, data);
    }, err => {
      callback(err);
    });

更新我已經列出了行不通的promise.all方法。 所以它不能被稱為重復

Answer 1

事情有點棘手，因為您有一個包含異步元素的外部.map()和內部.map() 。

異步元素有效地使整個事物變得異步，這要求：

• 內部.map()生成的Promises數組與Promise.all（）聚合，並且聚合的Promise返回到外部.map() 。
• 外部.map()生成的Promises數組將與Promise.all（）聚合。
• 結果（一組項目）只能通過鏈接的.then() 。

首先，要使主代碼塊更容易閱讀，請創建dspAccount.findAsync()的允許版本。

dspAccount.findAsync = function(query) {
    return new Promise(function(resolve, reject) {
        dspAccount.find(query, (err, data) => {
            if(err) {
                reject(err);
            } else {
                resolve(data);
            }
        });
    });
}

然后可以將主代碼塊編寫如下：

let outerPromises = _.chain(value)
.groupBy('pubId')
.pairs()
.map(function(currentItem) {
    let item = _.object(_.zip(['ID', 'targetting'], currentItem));
    item.targetting.forEach(d => {
        item.publishername = d.RTB.name;
        item.type = d.type;
        propsToBeDeleted.forEach(function(prop) {
            delete d[prop];
        });
    });
    let innerPromises = item.targetting.map(d => {
        let value = JSON.parse(d.value);
        if (d.type == 15) { // synchronous - `innerPromises` receives a null
            item.dspIds = []; // 
            d.name = Object.keys(value);
            d.value = Object.values(value)[0];
            return null;
        }
        if (d.type == 16) { // asynchronous - `innerPromises` receives a Promise
            return dspAccount.findAsync({where: {id: 139}})
            .then(data => {
                d.name = Object.keys(value).filter(d => d != 'profileId');
                item.dspIds = value.profileId;
                delete value.profileId;
                item.x = data;
                d.value = JSON.stringify(value);
            });
        }
    });
    return Promise.all(innerPromises).then(() => item); // aggregate inner promises and return
})
.value(); //  returns the outerPromises array

Promise.all(outerPromises)  // aggregate outer promises
.then(items => {
    // do stuff with items here
})
.catch(error => {
    // something went wrong
    // log/display error 
    // take remedial action as required
});

我希望還有很多工作要做。 應該在item.targetting.map()循環中對item進行item.targetting.map()似乎並不正確。 用於傳遞結果的item.targetting的最后一個元素（同步或異步）將確定item的組成。 那可能不是您想要的。 如果這是您想要的，則需要進行更多控制，以確保最后傳遞的結果是item.targetting的最后一個元素產生的結果。