Javascript 从对象数组返回具有最高键/值对的对象

给定一个对象数组，我想返回一个具有所有对象中最高值的对象

let countObj = [{2:1},{2:4, 5:1},{3:3}]
let finalObj = {}
let primes = [2,3,5]
// finalObj should return {2:4, 3:3, 5:1}

我觉得应该有一些方法来使用素数数组并在countObj上进行reduce以获得所需的结果

primes.forEach(p => countObj.reduce((a,b) =>{
                 if (a[p]){ //if prime no. exists as key in a
                      a[p] > b[p] ? //keep key/val pair in a : replace key/val pair
                    }else{ //if new prime is not a key in a
                      a[p] = b[p]
                    }    
               },{})

---

我不确定逻辑是否正确，而且我也不知道如何让它返回最终对象。

测试时要小心：0与缺少的值相同。使用

reduce

时，必须返回累加器对象

我要减少对象的数量，而不是减少素数的数量：

let finalObj = countObj.reduce((f, o)=>{
    primes.forEach(k=>{
       if (k in o && !(o[k]<f[k])) f[k]=o[k];
    });
    return f;
}, {});

让finalObj=countObj.reduce（（f，o）=>{
primes.forEach（k=>{
如果（k in o&&！（o[k]在测试时要小心：0与缺少的值相同。当使用
reduce
时，必须返回累加器对象

我要减少对象的数量，而不是减少素数的数量：

let finalObj = countObj.reduce((f, o)=>{
    primes.forEach(k=>{
       if (k in o && !(o[k]<f[k])) f[k]=o[k];
    });
    return f;
}, {});

让finalObj=countObj.reduce（（f，o）=>{
primes.forEach（k=>{
if（k in o&&！（o[k]您可以像这样使用嵌套的
foreach

在这种情况下，您不需要
素数[]
let countObj=[{
2: 1
}, {
2: 4,
5: 1
}, {
3: 3
}];
设finalObj={}；
设素数=[2,3,5]；
countObj.forEach（函数（obj）{
Object.keys（obj）.forEach（函数（key）{
var finalObjValue=finalObj[key]| | 0；
if（obj[key]>finalObjValue）
finalObj[key]=obj[key]；
});
});
console.log（finalObj）；
您可以像这样使用嵌套的
foreach

在这种情况下，您不需要
素数[]
let countObj=[{
2: 1
}, {
2: 4,
5: 1
}, {
3: 3
}];
设finalObj={}；
设素数=[2,3,5]；
countObj.forEach（函数（obj）{
Object.keys（obj）.forEach（函数（key）{
var finalObjValue=finalObj[key]| | 0；
if（obj[key]>finalObjValue）
finalObj[key]=obj[key]；
});
});
console.log（finalObj）；
您可以检查存储的值是否大于实际值，如果大于实际值，则将该值分配给结果集


var countObj=[{2:1}，{2:4,5:1}，{3:3}]，
finalObj={}；
countObj.forEach（o=>Object.keys（o）.forEach（k=>finalObj[k]>o[k]| |（finalObj[k]=o[k]）；
console.log（finalObj）；//{2:4,3:3,5:1}
您可以检查存储的值是否大于实际值，如果大于实际值，则将值分配给结果集


var countObj=[{2:1}，{2:4,5:1}，{3:3}]，
finalObj={}；
countObj.forEach（o=>Object.keys（o）.forEach（k=>finalObj[k]>o[k]| |（finalObj[k]=o[k]）；
console.log（finalObj）；//{2:4,3:3,5:1}
这对负数不起作用（这可能与OP有关，也可能与OP无关，但我不确定这对你来说是否明显）@DenysSéguret为什么？因为它们不是>0。只需使用{3:-1}而不是{3:3}进行测试。这对负数不起作用（这可能与OP有关，也可能与OP无关，但我不确定这对你来说是显而易见的）@DenysSéguret为什么？因为它们不是>0。只需用{3:-1}而不是{3:3}进行测试。为什么不删除！并翻转>就行了？例如，如果（k in o&（o[k]>f[k]）f[k]=o[k]@IsabellaChen，因为当o[k]或f[k]时不一样未定义。为什么不删除！并翻转>呢？即如果（k in o&&（o[k]>f[k]）f[k]=o[k]@IsabellaChen，因为当o[k]或f[k]未定义时是不同的。