Javascript 正在使用下划线.js查找嵌套集合中的对象

我有一个团队集合（在一个联盟中），如下所示：

以这种方式存储的每个var中大约有20个团队。然后，我有六个这样的联盟：

eng1

，

esp1

，

fra1

，

ger1

，

ita1

，和

usa1

。我把它们放在另一个集合中，如下所示：

var all = {
    "eng1":eng1,
    "esp1":esp1,
    "fra1":fra1,
    "ger1":ger1,
    "ita1":ita1,
    "usa1":usa1
}

现在，每支球队（不管他们在哪个联赛）都有一个唯一的ID：在上面的例子中，波尔多队有ID 159，PSG队有ID 160，依此类推。因此，我希望能够通过

teamid

（使用下划线.js）在

all

集合中搜索唯一的团队，但我无法完全理解语法。我知道我可以像这样搜索一个联赛：

var fra1 = {
   "sports":[
      {
         "name":"soccer",
         "id":600,
         "uid":"s:600",
         "leagues":[
            {
               "name":"French Ligue 1",
               "abbreviation":"fra.1",
               "id":710,
               "isTournament":false,
               "country":{
                  "id":7,
                  "name":"France",
                  "abbreviation":"FRA"
               },
               "uid":"s:600~l:710",
               "groupId":9,
               "shortName":"Ligue 1",
               "teams":[
                  {
                     "id":159,
                     "uid":"s:600~t:159",
                     "location":"Bordeaux",
                     "name":"Bordeaux",
                     "nickname":"Bordeaux",
                     "abbreviation":"BOR",
                     "color":"00003e",
                  },
                  {
                     "id":160,
                     "uid":"s:600~t:160",
                     "location":"Paris Saint-Germain ",
                     "name":"Paris Saint-Germain ",
                     "nickname":"Paris Saint-Germain ",
                     "abbreviation":"PSG",
                     "color":"000040",
                  }
               ]
            }
         ]
      }
   ],
}

var obj = _.find(fra1.sports[0].leagues[0].teams, function(obj) { return obj.id == teamid })

但我不知道如何在六个联赛中做到这一点。有人能帮忙吗？我不希望手动将这些集合合并成一个集合，因为这样会涉及大量数据

编辑：我当前正在使用：

for (var league in all)
{
    var obj = _.find(all[league].sports[0].leagues[0].teams, function(obj) { return obj.id == teamid })

    if (obj !== undefined)
    {   
        // do things
    }
}

---

但是我仍然想要更好的。一个解决方案是创建一个团队地图，以团队id为键，以团队为值：

var teams = {};

_.each(all, function(nation){
    _.each(nation.sports[0].leagues[0].teams, function(team){
        teams[team.id] = team;
    });
});

然后，您可以使用以下密钥访问团队：

var psg = teams[160];

---

只需在

运动

和

联赛

上进行附加循环，而不仅仅是在

所有

上：

for (var league in all) {
    var sports = all[league];
    for (var i=0; i<sports.length; i++) {
        var leagues = sports[i].leagues;
        for (var j=0; j<leagues.length; j++) {
            var teams = leagues[j].teams;
            // var obj = _.find(teams, function(obj) { return obj.id == teamid })
            for (var k=0; k<teams.length; k++) {
                var obj = teams[k];
                if (obj.id == teamid) {
                    … // do things
                }
            }
        }
    }
}

for（所有风险等级）{
var sports=所有[联盟]；
对于（var i=0；i，就解析其余团队而言，只需使用chain：

var allTeams = _.chain(all)
  .values()
  .pluck('sports').flatten()  // once
  .pluck('leagues').flatten() // twice
  .pluck('teams').flatten()   // third time's a charm
  .value()

我建议在teamID上使用u.groupBy（）。这将为您提供一个映射
teamID->teamObject
的哈希表（JS对象）。假设您的团队解析如下：

var allTeams =[
{
  "id":159,
  "uid":"s:600~t:159",
  "location":"Bordeaux",
  "name":"Bordeaux",
  "nickname":"Bordeaux",
  "abbreviation":"BOR",
  "color":"00003e",
},{
  "id":160,
  "uid":"s:600~t:160",
  "location":"Paris Saint-Germain ",
  "name":"Paris Saint-Germain ",
  "nickname":"Paris Saint-Germain ",
  "abbreviation":"PSG",
  "color":"000040",
}]

var myTeam = lookup[teamId]

您可以将它们分组为：

var lookup = _.groupBy(teams, 'id')

然后查找这样一个团队：

var allTeams =[
{
  "id":159,
  "uid":"s:600~t:159",
  "location":"Bordeaux",
  "name":"Bordeaux",
  "nickname":"Bordeaux",
  "abbreviation":"BOR",
  "color":"00003e",
},{
  "id":160,
  "uid":"s:600~t:160",
  "location":"Paris Saint-Germain ",
  "name":"Paris Saint-Germain ",
  "nickname":"Paris Saint-Germain ",
  "abbreviation":"PSG",
  "color":"000040",
}]

var myTeam = lookup[teamId]

这假设每个国家只有一项运动，每个运动只有一个联赛。这就是OP当前使用的。很好的一点，我仍然更喜欢u.groupBy，而不是通过u.each循环并手动构建映射。