Javascript 使用Promise.all将两个数组合并到其函数之外

我正试图通过id（event.id）将两个数组合并到一个数组中。我遇到了一个问题，我不明白如何在函数之外合并这些数组。我知道有一种方法可以用Promise.all实现，但我不知道如何实现。谢谢你抽出时间

function getpinnacle() {

  return new Promise(function (resolve, reject) {

    var options = {sportId: 29};
    pinnacle.getFixtures(options, function(err, response, body) {
      if (err) throw new Error(err);
      var pinnFixtures = [];
      body.league.forEach(function(leagues){
        leagues.events.forEach(function(event){ 
          if (event.status == 'O'){
            pinnFixtures.push({
              'id': event.id,
              'homeTeamName': event.home,
              'awayTeamName': event.away
            });
          };    
        });
      });
      resolve(pinnFixtures);
    });

    var options = {sportId: 29, oddsFormat: "DECIMAL"};
    pinnacle.getOdds(options, function(err, response, body) {
      if (err) throw new Error(err);
      var pinnOdds = [];
      body.leagues.forEach(function(league){
        league.events.forEach(function(event){
          event.periods.forEach(function(period){
            if (period.moneyline !== undefined) {
              pinnOdds.push({
                'id': event.id,
                'homeTeamOdds': period.moneyline.home,
                'drawOdds': period.moneyline.draw,
                'awayTeamOdds': period.moneyline.away
              }); 
            };
          });
        });
      });
      resolve(pinnOdds);
    });
  });

}
module.exports = getpinnacle;

---

为了获得两个数组都可用的上下文，您可以将每个回调封装在一个承诺中，然后使用

promise.all（）

等待结果：

function getpinnacle() {
    var options = {sportId: 29};
    const fixtures = new Promise(function(resolve, reject){
      pinnacle.getFixtures(options, function(err, response, body) {
        if (err) throw new Error(err);
        var pinnFixtures = [];
        body.league.forEach(function(leagues){
          leagues.events.forEach(function(event){ 
            if (event.status == 'O'){
              pinnFixtures.push({
                'id': event.id,
                'homeTeamName': event.home,
                'awayTeamName': event.away
              });
            };    
          });
        });
        resolve(pinnFixtures);
      });
    });

    var options = {sportId: 29, oddsFormat: "DECIMAL"};
    const odds = new Promise(function(resolve, reject){
      pinnacle.getOdds(options, function(err, response, body) {
        if (err) throw new Error(err);
        var pinnOdds = [];
        body.leagues.forEach(function(league){
          league.events.forEach(function(event){
            event.periods.forEach(function(period){
              if (period.moneyline !== undefined) {
                pinnOdds.push({
                  'id': event.id,
                  'homeTeamOdds': period.moneyline.home,
                  'drawOdds': period.moneyline.draw,
                  'awayTeamOdds': period.moneyline.away
                }); 
              };
            });
          });
        });
        resolve(pinnOdds);
      });
    });
    return Promise.all([fixtures, odds]);
}

---

之后，您可以调用

getPinnacle（）。然后（function（results）{…}）

其中results是一个数组

[fixtures，difficies]

为了获得一个上下文，其中两个数组都可用，您可以将每个回调封装在一个promise中，然后使用

promise.all（）

等待结果：

function getpinnacle() {
    var options = {sportId: 29};
    const fixtures = new Promise(function(resolve, reject){
      pinnacle.getFixtures(options, function(err, response, body) {
        if (err) throw new Error(err);
        var pinnFixtures = [];
        body.league.forEach(function(leagues){
          leagues.events.forEach(function(event){ 
            if (event.status == 'O'){
              pinnFixtures.push({
                'id': event.id,
                'homeTeamName': event.home,
                'awayTeamName': event.away
              });
            };    
          });
        });
        resolve(pinnFixtures);
      });
    });

    var options = {sportId: 29, oddsFormat: "DECIMAL"};
    const odds = new Promise(function(resolve, reject){
      pinnacle.getOdds(options, function(err, response, body) {
        if (err) throw new Error(err);
        var pinnOdds = [];
        body.leagues.forEach(function(league){
          league.events.forEach(function(event){
            event.periods.forEach(function(period){
              if (period.moneyline !== undefined) {
                pinnOdds.push({
                  'id': event.id,
                  'homeTeamOdds': period.moneyline.home,
                  'drawOdds': period.moneyline.draw,
                  'awayTeamOdds': period.moneyline.away
                }); 
              };
            });
          });
        });
        resolve(pinnOdds);
      });
    });
    return Promise.all([fixtures, odds]);
}

---

在这之后，您可以调用

getPinnacle（）。然后（function（results）{…}）

其中results是一个数组

[fixtures，赔率]

我要做的是重构代码，将

getFixtures

和

get赔率

分解为两个单独的函数，每个函数都返回一个承诺。然后getPinnacle将

返回Promise.all（getFixtures（），getLobbits（））

重构代码的方法是将

getFixtures

和

getLobbits

分解为两个单独的函数，每个函数都返回一个Promise。然后getPinnacle将

返回Promise.all（getFixtures（），GetOfficies（））

您可以这样使用Promise.all

function getpinnacle() {
   var promises = [];
   var fixturePromise = new Promise( (resolve, reject) => {
          ///add your code here and resolve from inside you getFixture method
   });
promises.push(fixturePromise);
var oddPromise = new Promise( (resolve, reject) => {
//add your getOdds method here and resolve this promise too
 });

 promise.push(oddPromise);

 Promise.all(promises).then( (response) => {
 var fixtureResponse = response[0];
var oddResponse = response[1];
//add your extra logic here
});
}

---

你可以用承诺，就像这样

function getpinnacle() {
   var promises = [];
   var fixturePromise = new Promise( (resolve, reject) => {
          ///add your code here and resolve from inside you getFixture method
   });
promises.push(fixturePromise);
var oddPromise = new Promise( (resolve, reject) => {
//add your getOdds method here and resolve this promise too
 });

 promise.push(oddPromise);

 Promise.all(promises).then( (response) => {
 var fixtureResponse = response[0];
var oddResponse = response[1];
//add your extra logic here
});
}

---

您可以创建任何承诺数组。然后在该数组中推送所有承诺，然后可以指定promise.all（）；你能给我举个例子吗？请从这里读：仍然不明白你可能会做出任何承诺。然后在该数组中推送所有承诺，然后可以指定promise.all（）；你能给我看一个例子吗？请从这里开始阅读：仍然不明白在什么地方应该有额外的逻辑，按照id显示不一致的装置，并且只显示那些不一致的装置？你可以在返回的承诺的

then

子句中，或者在函数中（最后一行）或者在返回值上。仔细看看我写的最后一行，它是如何使用它的。这里有一个更完整的例子：

getPinnacle（）.then（函数（结果）{dosomethingWithLobbits（结果[1]）}

app.get（'/bets'，函数（req，res）{getPinnacle（）.then（函数（结果）{return_u.map（函数（odddEvent）{var eventId=oddEvent.id；var fixtures=.find（fixtures，函数）（fixtureEvent）{return fixtureEvent.id==eventId；}；；}）；allods=results；res.send（JSON.stringify（results））；Promise.all（insertData（allods））；}）；var allods=[]；在这之前，但有点不对劲，我什么也没得到，甚至是一个错误。在这个错误中，应该有额外的逻辑，即fixture按id表示不一致，并且只显示那些不一致的fixture？您可以将其写入返回的承诺的

then

子句中，或者在函数中（最后一行）或者关于返回值。仔细看看我写的最后一行，它是如何使用它的。这里有一个更完整的示例：

getPinnacle（）.then（function（results）{dosomethingwithlobbs（results[1]）}

app.get（'/bets'，function（req，res）{getPinnacle（）.then（function（results）{return.map（function（oddEvent）{var-eventId=oddEvent.id；var-fixtures=551;.find（fixtures，function（fixtureEvent）{return-fixtureEvent.id==eventId；}）；}；allOdds=results；res.send（JSON.stringify（results））；Promise.all（insertData（allods））；}）；var allods=[]；在这之前，我什么也没得到，甚至是一个错误