如何比较对象中的元素并返回更高的值？ *Javascript*答案

【问题标题】：How to compare elements in an object and return the higher value? *Javascript*如何比较对象中的元素并返回更高的值？ *Javascript*
【发布时间】：2018-04-06 20:20:23
【问题描述】：

我正在尝试在 Javascript 中比较一个对象内的两个元素。具有最高值的字母应连同其携带的数字一起返回。

这是对象，我们应该返回 a 和 39。

obj({a:39,b:21,c:12,d:4}) // should return a : 39

这是我目前的代码。

let obj = object => {

  for(let i in object) { // i  represents the "key" of the objects, a,b,c,d
    if(object[i] > object[i + 1]) { // object[i] represents the "value" held 39,21,12,4
      console.log(i + ":" + object[i]);
    } else {
      console.log(i + ":" + object[i]);
    }
  }
}

obj({a:39,b:21,c:12,d:4})

我认为 if 语句中的 object[i + 1] 会将下一个索引元素与当前元素进行比较，但事实并非如此，您将如何实现呢？

EDIT 如果有两个元素的值相同，则返回两个元素

对于像我这样的编码新手来说，这可能是最简单的方法。此代码返回对象中保存的最大数字。

let getMax = (obj) => {
  let highestValue = 0;
  for(var i in obj) {
    if(highestValue < obj[i]) {
      highestValue = obj[i];
    } else if (highestValue == obj[i]) {
      highestValue = highestValue + " " + obj[i];
    }
  }
  alert(highestValue);
}
getMax({John:300000,Kary:360000,David:2700000,Michelle:2700000})

【问题讨论】：

您可能想使用Object.keys() 并将它们作为数组进行迭代。然后，您可以将i+1 作为下一个键的索引向前看。显然，请确保您不要越过键数组的末尾。
超过一个 max 属性会发生什么？
感谢 veddermatic。我想知道如何像数组一样向前看。你把它清理干净了：）
好问题尼娜。如果超过一个 max 属性，则返回两者。我会尝试编辑问题。
为什么你认为object[i + 1] 会比较下一个元素？当i 是"a" 时i + 1 是"a1"，而不是"b"。它是一个对象，而不是一个数组。

标签： javascript loops object for-in-loop

【解决方案1】：

在每次迭代时检查当前或前一个键值是否最大，并存储。将最大的存储在 largest 变量中。最后返回largest变量，它的值（object[largest]）：

let obj = object => {
  let largest;
  for(const i in object) { // i  represents the "key" of the objects, a,b,c,d
    if(!largest || object[i] > object[largest]) {
      largest = i;
    }
  }
  
  return { [largest]: object[largest] };
}

console.log(obj({a:39,b:21,c:12,d:4}));

建议的解决方案：

使用Object.entries() 获取键|值对。使用 Array.reduce() 进行迭代，选择具有最高值的对（索引 1）。 Destructurereduce 的结果（带有[key, value] 的数组）转换为key 和值常量，并使用它们构建返回对象。

const obj = (object) => {
  const [key, value] = Object.entries(object)
    .reduce((r, e) => e[1] > r[1] ? e : r);
  return { [key]: value };
};
  
console.log(obj({a:39,b:21,c:12,d:4}));

【讨论】：

为什么要做const[key, value]是什么意思？
reduce的结果是一个[key, value]形式的数组。我想将创建函数返回的对象所需的 key 和 value const 分解（解构）。
我现在理解你的方法，我喜欢它，谢谢你为我分解它。

【解决方案2】：

for(let i in object)

返回对象键

所以 i+1 = a : a1, b:b1, c:c1

这将是正确的代码：

let obj = object => {
let returnValue;
for(let i in object) { // i  represents the "key" of the objects, a,b,c,d
  if(typeof(returnValue)==="undefined"){
    returnValue = object[i];
  } else if (object[i] > returnValue) {
    returnValue=object[i];
  }
}
return returnValue;
}
obj({a:39,b:21,c:12,d:4})

【讨论】：

【解决方案3】：

您可以收集键并使用最大值渲染对象。

function getMax(object) {
    return Object.assign(
        ...Object
            .keys(object).reduce((r, k) => {
                if (!r || object[r[0]] < object[k]) {
                    return [k];
                }
                if (object[r[0]] === object[k]) {
                    r.push(k);
                }
                return r;
            }, undefined)
            .map(k => ({ [k]: object[k] }))
    );
}

console.log(getMax({ a: 39, b: 21, c: 12, d: 4, foo: 39 }));

【讨论】：

有点领先于我的技能水平，但我会研究你的代码并学习它，它会让我变得更好。感谢您花时间帮助我:)

【解决方案4】：

当您执行let i in object 时，您将遍历对象中的每个键。所以在这种情况下，i 在每次迭代后分别为 a、b、c 和 d。

这就是object[i+1] 不起作用的原因。因为在i 为“a”的第一次迭代中，解释器将其读取为object['a' + 1]，结果为object['a1']。

有几种方法可以解决这个问题。

一种方法是使用Object 类的keys 函数，该函数返回一个键数组，然后您可以在该结果上调用map 以循环遍历每个键，您还将有一个索引每一个。即：

let obj = object => {
  var keys = Object.keys(object);
  keys.map(function(key, index) {
    console.log("Current value: " + object[key]);
    console.log("Current index: " + index);
    console.log("Current key: " + key);
    console.log("Next value: " + object[keys[index + 1]]); // you should probably check if you're at the last index before you do this
    console.log("-------------");
  });
};
obj( {a:39,b:21,c:12,d:4} );

您可以采用的另一条路线是使用 for 循环并创建一个迭代器变量，如下所示：

let obj = object => {
  var keys = Object.keys(object);

  for(var i = 0; i < keys.length; i++) {
    console.log('Current Value: ' + object[keys[i]]);
    console.log('Next Value: ' + object[keys[i + 1]]); // also probably do a check here to see if you're already at the last index
  }
};
obj( {a:39,b:21,c:12,d:4} );

在上述情况下，i 始终是一个数字。然后我们循环遍历对象中存在的key的数量，然后使用i得到我们想要的key。然后将该键放入对象中，我们将获得您要比较的值。

【讨论】：

【解决方案5】：

获取所有索引/值（如果存在多个最大值），

使用Object.entries获取键/值对，
那么当使用Array.reduce循环pairs时，设置reduce的初始值={max:0, data:[]}

注释：max 保存最大值，data 保存具有最大值的对。并假设值> 0，因此设置max = 0的初始值（您可以根据需要更改初始值）。

在循环中，比较值，

如果cur > max，将其推送到pre.data并更新pre.max。

如果cur===max，推送到pre.data，

如果cur<max，什么也不做。

const obj = {a:39,b:21,c:12,d:4,e:39}
result = Object.entries(obj).reduce(function(pre, cur){
  if(pre.max < cur[1]){
    pre.data = []
    pre.max = cur[1]
    pre.data.push({[cur[0]]:cur[1]})
  }
  else if(pre.max === cur[1]){
    pre.data.push({[cur[0]]:cur[1]})
  }
  return pre
},{max:0, data:[]})
console.log(result.data)

【讨论】：