Javascript 一个团队所有目标的数量（来自JSON）

我有一个包含足球比赛数据的JSON文件

[
   {
      "game_id":"258716",
      "game_date_start":"2016-08-15",
      "season": "2016",
      "team_1_id":"119",
      "team_2_id":"120",      
      "team_1_goals_quantity":"2",
      "team_2_goals_quantity":"1",         
   },
   {
      "game_id":"258717",
      "game_date_start":"2016-09-15",
      "season": "2016",
      "team_1_id":"119",
      "team_2_id":"122",      
      "team_1_goals_quantity":"1",
      "team_2_goals_quantity":"1"     
   },
   {
      "game_id":"258718",
      "game_date_start":"2016-07-15",
      "season": "2016",
      "team_1_id":"121",
      "team_2_id":"119",     
      "team_1_goals_quantity":"1",
      "team_2_goals_quantity":"1"      
   }
]

任务1。计算每个队的比赛总数

任务2。计算一个团队的总进球数（在所有比赛中）

我正在使用Vue.js。我通过以下方式解决了任务1：

 countGames() {     
            var data = this.$store.getters.games; 
            var arr1 = []; 
            var obj1 = {}; 

            //Here I got all unique Team IDs
            function getMatches() { 
                    for (var i in data) {        
                          obj1[data[i].team_1_id] = (obj1[data[i].team_1_id] || 0) + 1;
                          obj1[data[i].team_2_id] = (obj1[data[i].team_2_id] || 0) + 1
                    };      
                    Object.keys(obj1).forEach(function(el, data) {
                        arr1.push( [ el, obj1[el]] );                       
                    });                          
                 }; 
            getMatches();          
            var result = arr1.map(
                  ([team_id, matches]) => ({team_id, matches}) //here I got { {team_id: "119", matches: 3}, {team_id: "120", matches: 1} ... }
            );
            return result;                 
        }  

它起作用了。但我不知道如何解决任务2——计算每支球队在所有比赛中的总进球数。问题在于，有时团队的唯一ID可能位于团队1号，有时位于团队2号（如JSON示例中的团队“119”i）

---

请帮我写这个脚本

如果您坚持让代码保持原样，您可能会添加另一个对象来跟踪目标，如下所示：

 function countGames() {
      var data = this.$store.getters.games;      
      var arr1 = []; 
      var goalsPerTeam = []; // keep track of goals here
      var obj1 = {}; 

      //Here I got all unique Team IDs
      function getMatches() { 
              for (var i in data) {        
                    obj1[data[i].team_1_id] = (obj1[data[i].team_1_id] || 0) + 1;
                    obj1[data[i].team_2_id] = (obj1[data[i].team_2_id] || 0) + 1;
                    // add goals count
                    if (goalsPerTeam[data[i].team_1_id] === undefined) {
                      goalsPerTeam[data[i].team_1_id] = parseInt(data[i].team_1_goals_quantity);
                    } else {
                      goalsPerTeam[data[i].team_1_id] += parseInt(data[i].team_1_goals_quantity);
                    }

                    if (goalsPerTeam[data[i].team_2_id] === undefined) {
                      goalsPerTeam[data[i].team_2_id] = parseInt(data[i].team_2_goals_quantity);
                    } else {
                      goalsPerTeam[data[i].team_2_id] += parseInt(data[i].team_2_goals_quantity);
                    }
              };      
              Object.keys(obj1).forEach(function(el, data) {
                  arr1.push( [ el, obj1[el], goalsPerTeam[el]] );  // update this                   
              });                          
           }; 
        getMatches();          
        var result = arr1.map(
              // add here finally
              ([team_id, matches, goals]) => ({team_id, matches, goals}) //here I got { {team_id: "119", matches: 3}, {team_id: "120", matches: 1} ... }
        );
        return result;                 
      }  

    let totalGames = {},
        totalGoals = {};

    data.map( game => {

        //count games team 1
        if (!totalGames.hasOwnProperty(game.team_1_id)) {
            totalGames[game.team_1_id] = 1;
        } else {
            totalGames[game.team_1_id] += 1;
        }
        //count games team 2
        if (!totalGames.hasOwnProperty(game.team_2_id)) {
            totalGames[game.team_2_id] = 1;
        } else {
            totalGames[game.team_2_id] += 1;
        }

        //count goals team 1
        if (!totalGoals.hasOwnProperty(game.team_1_id)) {
            totalGoals[game.team_1_id] = parseInt(game.team_1_goals_quantity);
        } else {
            totalGoals[game.team_1_id] += parseInt(game.team_1_goals_quantity);
        }

        //count goals team 2
        if (!totalGoals.hasOwnProperty(game.team_2_id)) {
            totalGoals[game.team_2_id] = parseInt(game.team_2_goals_quantity);
        } else {
            totalGoals[game.team_2_id] += parseInt(game.team_2_goals_quantity);
        }
    });

---

您可以映射数组的每个对象，并递增相应的计数器，以获得如下数据：

 function countGames() {
      var data = this.$store.getters.games;      
      var arr1 = []; 
      var goalsPerTeam = []; // keep track of goals here
      var obj1 = {}; 

      //Here I got all unique Team IDs
      function getMatches() { 
              for (var i in data) {        
                    obj1[data[i].team_1_id] = (obj1[data[i].team_1_id] || 0) + 1;
                    obj1[data[i].team_2_id] = (obj1[data[i].team_2_id] || 0) + 1;
                    // add goals count
                    if (goalsPerTeam[data[i].team_1_id] === undefined) {
                      goalsPerTeam[data[i].team_1_id] = parseInt(data[i].team_1_goals_quantity);
                    } else {
                      goalsPerTeam[data[i].team_1_id] += parseInt(data[i].team_1_goals_quantity);
                    }

                    if (goalsPerTeam[data[i].team_2_id] === undefined) {
                      goalsPerTeam[data[i].team_2_id] = parseInt(data[i].team_2_goals_quantity);
                    } else {
                      goalsPerTeam[data[i].team_2_id] += parseInt(data[i].team_2_goals_quantity);
                    }
              };      
              Object.keys(obj1).forEach(function(el, data) {
                  arr1.push( [ el, obj1[el], goalsPerTeam[el]] );  // update this                   
              });                          
           }; 
        getMatches();          
        var result = arr1.map(
              // add here finally
              ([team_id, matches, goals]) => ({team_id, matches, goals}) //here I got { {team_id: "119", matches: 3}, {team_id: "120", matches: 1} ... }
        );
        return result;                 
      }  

    let totalGames = {},
        totalGoals = {};

    data.map( game => {

        //count games team 1
        if (!totalGames.hasOwnProperty(game.team_1_id)) {
            totalGames[game.team_1_id] = 1;
        } else {
            totalGames[game.team_1_id] += 1;
        }
        //count games team 2
        if (!totalGames.hasOwnProperty(game.team_2_id)) {
            totalGames[game.team_2_id] = 1;
        } else {
            totalGames[game.team_2_id] += 1;
        }

        //count goals team 1
        if (!totalGoals.hasOwnProperty(game.team_1_id)) {
            totalGoals[game.team_1_id] = parseInt(game.team_1_goals_quantity);
        } else {
            totalGoals[game.team_1_id] += parseInt(game.team_1_goals_quantity);
        }

        //count goals team 2
        if (!totalGoals.hasOwnProperty(game.team_2_id)) {
            totalGoals[game.team_2_id] = parseInt(game.team_2_goals_quantity);
        } else {
            totalGoals[game.team_2_id] += parseInt(game.team_2_goals_quantity);
        }
    });

---

只关注目标计数，我的解决方案是创建一个只包含团队目标对的字典，然后将其汇总到团队目标编号数组中：

function count_team_goals(json){

   // create a summary json
   let summ = []
   for(i in json){
      team_1 = {'team': json[i]['team_1_id'], 'goals': json[i]['team_1_goals_quantity']};
      team_2 = {'team': json[i]['team_2_id'], 'goals': json[i]['team_2_goals_quantity']};
      summ.push(team_1)
      summ.push(team_2);
   }

   // count the team goals with reduce and return
   let summ_d = summ.reduce(function(e, c) {
      e[c.team] = e[c.team] || {'team_id': c.team, 'goals': 0};
      e[c.team]['goals'] = e[c.team]['goals'] + parseInt(c.goals);
      return e;
   }, {})

   // return array
   return Object.keys(summ_d).map(k => summ_d[k])
}

---

你可以这样做

const getResultsByTeamId = (id) => {
  const matches = list
    .filter((match) => match.team_1_id === id || match.team_2_id === id)

  const goals = matches
    .map((match) => match.team_1_id === id
      ? match.team_1_goals_quantity
      : match.team_2_goals_quantity)
    .reduce((acc, goals) => acc + parseInt(goals), 0)

  return {
    matches: matches.length,
    goals
  }
}

然后打电话

// The argument is a string because your ID is a string, not a number.
getResultsByTeamId('119') #returns { matches: 3, goals: 4 }
getResultsByTeamId('120') #returns { matches: 1, goals: 1 }
getResultsByTeamId('121') #returns { matches: 1, goals: 1 }
getResultsByTeamId('122') #returns { matches: 1, goals: 1 }

---

快速解释：首先，您将筛选团队成员为团队1或团队2的比赛。然后你只得到球队的目标，然后你求和。

游戏id总是一样的吗？它应该是不同的，对吧？是的，每次都不同，谢谢你的提醒。你的解决方案对我有效，但部分有效。不知何故，它只计算球队在上一场比赛中的罚球，而不是所有进球的总和。所以我得到了“119”：1个进球，而不是“119”：3个进球。你能告诉我是什么原因吗？很抱歉，我以前没有很好地测试过。请检查编辑后的答案。通过这个示例数据，它派生出团队“119”：4个目标（2+1+1）。