我试图比较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]会将下一个索引元素与当前元素进行比较，但它不会，你会怎样做到这一点？
编辑 如果有两个元素具有相同的值，则返回两个元素
对于像我这样的新编码人员来说，这可能是最简单的方法。此代码返回对象中保存的最大数字。
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})
答案 0 :(得分：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）。 Destructure将reduce的结果（带有[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}));
答案 1 :(得分：1)
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})
答案 2 :(得分：1)
您可以收集键并使用最大值渲染对象。
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 }));
答案 3 :(得分：1)
执行let i in object后，您将遍历对象中的每个键。所以在这种情况下，i在每次迭代后分别为a，b，c和d。
这就是object[i+1]无效的原因。因为在第一次迭代时i是＆＃34; a＆＃34;，解释器将其读作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始终是一个数字。然后我们遍历对象中的键数，然后使用i来获取我们想要的键。然后将该键放入对象中，我们将获得您想要比较的值。
答案 4 :(得分：0)
获取所有索引/值（如果存在多个最大值），
使用Object.entries获取键/值对，
然后在使用Array.reduce循环对时，设置reduce = {max:0, data:[]}的初始值
评论：最大保存最大值，数据保存具有最大值的对。 并且假设值是> 0，所以设置max = 0的初始值（你可以根据需要改变初始值）。
if cur > max，将其推入pre.data并更新pre.max。
if 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)