Javascript 查找具有最大值的父对象

我是javascript新手，所以这个问题听起来很基本

var data = [
 { Amy: {items:[{shirt: 12},{trouser: 10}] } },
 { Bill: {items:[{shirt: 10},{trouser: 11}] } },
 { Chet: {items:[{shirt: 11},{trouser: 12}] } }
];

我正在尝试编写一个函数来返回谁拥有最多数量的衬衫。所以我写了两个这样的函数，首先得到最大值

    var shirtValues = data.map(function(obj) {return obj.items[shirts]; });
    var maxValue = Math.max.apply(null, shirtValues);
    console.log(maxValue);

---

现在我需要找出谁是获得最多衬衫数量的人。如何实现这一点？

如果您的JSON结构始终是这样。然后，您可以使用此方法查找最大衬衫数量：

var max=0;
var maxShirtCount=null;
data.forEach(function(ele,ind){ 
  currVal = ele[Object.keys(ele)[0]].items[0].shirt;
  if(currVal>max){
    max=currVal;
    maxShirtCount=ele;
  }
});
console.log(maxShirtCount);

最大裤数：

var max=0;
var maxTrouserCount=null;
data.forEach(function(ele,ind){ 
  currVal = ele[Object.keys(ele)[0]].items[1].trouser;
  if(currVal>max){
    max=currVal;
    maxTrouserCount=ele;
  }
});
console.log(maxTrouserCount);

---

如果您的JSON结构是这样的，则始终如此。然后，您可以使用此方法查找最大衬衫数量：

var max=0;
var maxShirtCount=null;
data.forEach(function(ele,ind){ 
  currVal = ele[Object.keys(ele)[0]].items[0].shirt;
  if(currVal>max){
    max=currVal;
    maxShirtCount=ele;
  }
});
console.log(maxShirtCount);

最大裤数：

var max=0;
var maxTrouserCount=null;
data.forEach(function(ele,ind){ 
  currVal = ele[Object.keys(ele)[0]].items[1].trouser;
  if(currVal>max){
    max=currVal;
    maxTrouserCount=ele;
  }
});
console.log(maxTrouserCount);

---

您可以获取密钥，如

name

，获取所需物品的计数，并与之前人员的计数进行比较。如果max相同，则扩展结果数组，如果更大，则返回包含max数据的新对象

函数getMax（项）{
返回数据.reduce（函数（r，a）{
var name=Object.keys（a）[0]，
count=a[name]。items.reduce（函数s，b）{
返回s+（b[项目]| | 0）；
}, 0);
如果（计数>=r.count）{
如果（计数>反计数）{
返回{item:item，name:[name]，count:count}；
}
r、 name.push（name）；
}
返回r；
}，{item:item，名称：[]，计数：0}）；
}
var数据=[{Amy:{items:[{shirt:12}，{streamer:10}]}，{Bill:{items:[{shirt:10}，{streamer:11}]}，{Chet:{items:[{shirt:11}，{streamer:12}}}}]，
maxShirt=getMax（“衬衫”）；
console.log（maxShirt）；//具有最大计数的所有名称
console.log（maxShirt.names）；//只需姓名

您就可以获得钥匙，如

姓名

，获取所需物品的计数，并与之前人员的计数进行比较。如果max相同，则扩展结果数组，如果更大，则返回包含max数据的新对象

函数getMax（项）{
返回数据.reduce（函数（r，a）{
var name=Object.keys（a）[0]，
count=a[name]。items.reduce（函数s，b）{
返回s+（b[项目]| | 0）；
}, 0);
如果（计数>=r.count）{
如果（计数>反计数）{
返回{item:item，name:[name]，count:count}；
}
r、 name.push（name）；
}
返回r；
}，{item:item，名称：[]，计数：0}）；
}
var数据=[{Amy:{items:[{shirt:12}，{streamer:10}]}，{Bill:{items:[{shirt:10}，{streamer:11}]}，{Chet:{items:[{shirt:11}，{streamer:12}}}}]，
maxShirt=getMax（“衬衫”）；
console.log（maxShirt）；//具有最大计数的所有名称
console.log（maxShirt.names）；//只需名称

我将从更改数据结构开始。如果不进行过度迭代，很难看出当前格式在迭代、聚合、获取用户名、获取项目名称等方面有多大用处

这里有一种更易于使用的替代数据结构，因为它没有嵌套数组，也不需要

对象。键
来一致访问所需的数据（例如用户名）：

使用此格式，您可以轻松地按特定项目数量进行排序：

let getTopItem = (data, itemName) => {
  // 1. clone the array using concat
  // 2. sort by value at supplied itemName
  // 3. return the first item
  let sorted = data.concat().sort((a, b) => {
    return b.items[itemName] - a.items[itemName];
  });
  return sorted.shift();
}

let topShirts = getTopItem(data, 'shirt');
console.log(topShirts.user);

编辑-我对任何答案都不是消极的，因为它们似乎都是从呈现的数据结构中获取所需数据的正确且有用的方法-但看看它们都需要多少次迭代才能从对象中获取这些非常基本的数据。为数据选择正确的结构将为您节省很多麻烦。
我将从更改数据结构开始。如果不进行过度迭代，很难看出当前格式在迭代、聚合、获取用户名、获取项目名称等方面有多大用处

var data = [
 { Amy: {items:[{shirt: 12},{trouser: 10}]  } },
 { Bill: {items:[{shirt: 10},{trouser: 11}] } },
 { Chet: {items:[{shirt: 11},{trouser: 12}] } }
];

function doSort(a, b){
  return a[Object.keys(a)].items[0].shirt < b[Object.keys(b)].items[0].shirt;
}

console.log(Object.keys(data.sort(doSort)[0])[0]);

这里有一种更易于使用的替代数据结构，因为它没有嵌套数组，也不需要
对象。键
来一致访问所需的数据（例如用户名）：

使用此格式，您可以轻松地按特定项目数量进行排序：

let getTopItem = (data, itemName) => {
  // 1. clone the array using concat
  // 2. sort by value at supplied itemName
  // 3. return the first item
  let sorted = data.concat().sort((a, b) => {
    return b.items[itemName] - a.items[itemName];
  });
  return sorted.shift();
}

let topShirts = getTopItem(data, 'shirt');
console.log(topShirts.user);

编辑-我对任何答案都不是消极的，因为它们似乎都是从呈现的数据结构中获取所需数据的正确且有用的方法-但看看它们都需要多少次迭代才能从对象中获取这些非常基本的数据。为数据选择正确的结构将为您节省很多麻烦。
var data=[
var data = [
 { Amy: {items:[{shirt: 12},{trouser: 10}]  } },
 { Bill: {items:[{shirt: 10},{trouser: 11}] } },
 { Chet: {items:[{shirt: 11},{trouser: 12}] } }
];

function doSort(a, b){
  return a[Object.keys(a)].items[0].shirt < b[Object.keys(b)].items[0].shirt;
}

console.log(Object.keys(data.sort(doSort)[0])[0]);

{Amy:{项目：[{衬衫：12}，{裤子：10}}}，
{账单：{项目：[{衬衫：10}，{裤子：11}]}，
{Chet:{项目：[{衬衫：11}，{裤子：12}]}
];
函数doSort（a，b）{
返回一个[Object.keys（a）]。项目[0]。衬衫
var数据=[
{Amy:{项目：[{衬衫：12}，{裤子：10}}}，
{账单：{项目：[{衬衫：10}，{裤子：11}]}，
{Chet:{项目：[{衬衫：11}，{裤子：12}]}
];
函数doSort（a，b）{
返回一个[Object.keys（a）]。项目[0]。衬衫
如果您不能更改数据结构，
reduce
函数可以非常方便地满足您的需要。事实上，逻辑变得非常直截了当！。代码如下所示：


var数据=[
{Amy:{项目：[{衬衫：12}，{裤子：10}}}，
{账单：{项目：[{衬衫：10}，{裤子：11}]}，
{Chet:{项目：[{衬衫：11}，{裤子：12}]}
];
var new_data=data.reduce（函数（max，obj）{
var obj_val；
var max_val；
max_val=get_shirt_val（max）；
obj_val=获取衬衫（obj）；
返回obj_val>max_val？obj:max；
});
函数get_shirt_val（obj）{
key=Object.keys（obj）[0]
ret