查找具有最大值的父对象

我将从更改数据结构开始。很难看出当前的格式在迭代、聚合、获取用户名、获取项目名等方面有多么有用，而不需要过度迭代。

这是一种更容易使用的替代数据结构，因为它没有嵌套数组，也不需要Object.keys访问您始终需要的数据(例如用户名):

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

使用这种格式，您可以很容易地按特定的项目数量进行排序:

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);

EDIT—我并不是说这对任何答案都是负面的，因为它们似乎都是从所呈现的数据结构中获取所需数据的正确和有用的方法—但是看看它们都需要多少次迭代才能从您的对象中获取这些非常基本的数据。为数据选择正确的结构将为您省去很多麻烦。

如果不能更改数据结构，则reduce函数可以非常方便地满足您的目的。实际上，逻辑变得非常简单!代码如下所示:

    var data = [
     { Amy: {items:[{shirt: 12},{trouser: 10}] } },
     { Bill: {items:[{shirt: 10},{trouser: 11}] } },
     { Chet: {items:[{shirt: 11},{trouser: 12}] } }
    ];
    var new_data = data.reduce(function(max, obj) {
    	var obj_val;
    	var max_val;
 
    	max_val = get_shirt_val(max);
	    obj_val = get_shirt_val(obj);
  
	    return obj_val > max_val ? obj : max;
    });
    function get_shirt_val(obj) {
        key = Object.keys(obj)[0]
   		return obj[key].items[0].shirt;
    }
    console.log(JSON.stringify(new_data));
    console.log(Object.keys(new_data)[0])

希望这对你有帮助!

如果您的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);

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]);

您可以获取键，如name，获取所需项目的计数，并与先前人员的计数进行比较。如果max相同，则扩展结果数组，如果max更大，则返回一个包含max数据的新对象。

function getMax(item) {
    return data.reduce(function (r, a) {
        var name = Object.keys(a)[0],
            count = a[name].items.reduce(function (s, b) {
                return s + (b[item] || 0);
            }, 0);
        if (count >= r.count) {
            if (count > r.count) {
                return { item: item, names: [name], count: count };
            }
            r.names.push(name);
        }
        return r;
    }, { item: item, names: [], count: 0 });
}
var data = [{ Amy: { items: [{ shirt: 12 }, { trouser: 10 }] } }, { Bill: { items: [{ shirt: 10 }, { trouser: 11 }] } }, { Chet: { items: [{ shirt: 11 }, { trouser: 12 }] } }],
    maxShirt = getMax('shirt');
console.log(maxShirt);       // all names with max count
console.log(maxShirt.names); // just the names

如果不进行排序并使用单遍缩减，您可以执行以下操作;

var data = [{ Amy: {items:[{shirt: 12},{trouser: 10}] } }, { Bill: {items:[{shirt: 10},{trouser: 11}] } }, { Chet: {items:[{shirt: 11},{trouser: 12}] } }
], 
  result = data.reduce((p,c) => { var sc = c[Object.keys(c)[0]].items[0].shirt;
                                  return sc > p[0] ? [sc,c] : p;
                                },[0,{}])[1];
console.log(result);