对象中的最高值（如果存在更多且相同的最大值，则为更多）

Question

假设我有这样的对象：

var obj = {a : 5, b : 10, c : 15, d : 20, e : 20, f : 25};

我想获得前3个最高值-请注意d和e键具有相同的值，我也需要获取键，因此它看起来像：

最高值：f-25d-20e-20

例如，如果还有六个值并且四个相同：

var obj2 = {a:1, b:1, c:1, d:1, e:0,8, f: 0,5};

我需要显示4最高。

最高值：1一1一1一d-1

我想有必要遍历所有对象属性以获取Math.max，但我还需要一些东西来计算其键的3个最大数字，如果还有更多（相同的话），我需要“他们所有人！”

编辑：到目前为止我的代码：

var obj = {a : 5, b : 10, c : 15, d : 20, e : 20, f : 25};
var arr = Object.keys(obj).map(function(key)
{
  return obj[key];
});
var max = Math.max.apply(null, arr);
console.log(max);

考虑如何通过最佳方式做到这一点。

Answer 1

所以，您想找到前三名，如果有多个相同的最高，那么您希望包括所有这些。

这个问题以一种有点怪异的方式提出。

我将假设，如果存在a：1 b：1 c：2 d：2 e：3之类的东西，您想包含a，b，c和d。

首先，您只需要跟踪键，因为您可以在最后立即获取值。

好！开始吧。 （高效但难看）

class Numandamount {
  constructor(number, amount) {
    this.number = number;
    this.amount = amount;
  }
}
//That's just a class to link numbers and their amounts

var numtoamount = [];

//Now let's fill that array!

for (var property in obj) {
  if (obj.hasOwnProperty(property)) {
    var num = obj.property;
    var found = false;
    for(Numandamount naa in numtoamount){
       if(naa.number == num){
           naa.amount++;
           found = true;
       }
    }
    if(!found){
       naa.push(new Numandamount(num,1));
    }
  }
}

//The array is done!

numtoamount.sort(function(a,b){return b.number-a.number});

//Now all we have to do is loop through it!

var count = 0; // keep track of how many we did
var i = 0;
while(count<4 && i<numtoarray.length){
    count += numtoamount[i].amount;
    i++;
}
//BOOOM WE DID IT
// I is the biggest index so all we have to do is:

for(var j = 0;j<i;j++){
   console.log("We have "+numtoamount[j].amount+" "+numtoamount[j].number+"'s");
}

例如它将在此示例中打印出obj：{a：1 b：1 c：4 d：6 e：7 f：4}

我们有1 7我们有1 6我们有2 4's

如果您需要其他实现，请在下面评论！我全心投入了这个<3

Answer 2

这是一个示例实现，带有注释以解释每个步骤发生的事情。

function maxValues(o, n) {
  // Get object values and sort descending
  const values = Object.values(o).sort((a, b) => b - a);
  
  // Check if more values exist than number required
  if (values.length <= n) return o;
  
  // Find nth maximum value
  const maxN = values[n - 1];
  
  // Filter object to return only key/value pairs where value >= maxN
  return Object.entries(o)
    .reduce((o, [k, v]) => v >= maxN ? { ...o, [k]: v } : o, {});
}

const a = maxValues({
  a: 5, 
  b: 10, 
  c: 15, 
  d: 20, 
  e: 20, 
  f: 25
}, 3);
console.log(a);

const b = maxValues({
  a: 1, 
  b: 1, 
  c: 1, 
  d: 1, 
  e: 0.8, 
  f: 0.5
}, 3);
console.log(b);

const c = maxValues({
  a: 5, 
  b: 10,
}, 3);
console.log(c);

Answer 3

我将从将您的对象转换为对象数组开始：

const arr = []

for (var key in obj){
  arr.push( {[key]: obj[key]} )
}

现在您有了一个看起来像这样的数组：

[
  {
    "f": 25
  },
  {
    "d": 20
  },
  {
    "e": 20
  },
  {
    "c": 15
  },
  {
    "b": 10
  },
  {
    "a": 5
  }
]

现在您可以按对象的大小对它们进行排序：

const sortedArray = arr.sort( (a,b) => { 
  if (Object.values(a)[0] > Object.values(b)[0]) {
    return -1
  } 
})

哪个会给：

[
  {
    "f": 25
  },
  {
    "d": 20
  },
  {
    "e": 20
  },
  {
    "c": 15
  },
  {
    "b": 10
  },
  {
    "a": 5
  }
]

然后，您可以从想要的顶部中选择任意多个值。例如

sortedArray.filter( (item, index) => {
  if (index <= 2) {
    return item
  }
})

哪个给：

[
  {
    "f": 25
  },
  {
    "d": 20
  },
  {
    "e": 20
  }
]