如何比较对象中的元素和 return 中较高的值？ Javascript

Question

我正在尝试比较 Javascript 中对象内的两个元素。具有最高价值的字母，应该 return 与其携带的数字一起编辑。

这是对象，我们应该returna和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 语句中的对象 [i + 1] 会将下一个索引元素与当前元素进行比较，但它不会，您将如何完成此操作？

编辑 如果有两个元素具有相同的值那么return两个元素

对于像我这样刚接触编码的人来说，这可能是完成此任务的最简单方法。此代码 return 是对象中保存的最大数字。

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

Answer 1

在每次迭代中检查当前或先前的键值是否最大，并存储。将最大的存储在 largest 变量中。最后 return 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() to get key|value pairs. Iterate with Array.reduce(), choose the pair with the highest value (index 1). Destructure reduce 的结果（[key, value] 的数组）到key 和值常量，并使用它们构建return 对象。

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

Answer 2

for(let i in object)

returns 对象键

所以 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})

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

Answer 4

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

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

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

一种方法是使用 Object class 的 keys 函数，其中 returns 一个键数组，然后您可以调用 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。然后将该键放入对象中，我们将获得您要比较的值。

Answer 5

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

使用Object.entries得到key/value对，
然后在使用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)

如何比较对象中的元素和 return 中较高的值？ Javascript

How to compare elements in an object and return the higher value? Javascript

javascript

loops

object

for-in-loop

如何比较对象中的元素和 return 中较高的值？ *Javascript*

How to compare elements in an object and return the higher value? *Javascript*

javascript

loops

object

for-in-loop

如何比较对象中的元素和 return 中较高的值？ Javascript

How to compare elements in an object and return the higher value? Javascript