Question

我有一系列对象，如下所示： -

[
    {
        'name': 'P1',
        'value': 150
    },
    {
        'name': 'P1',
        'value': 150
    },
    {
        'name': 'P2',
        'value': 200
    },
    {
        'name': 'P3',
        'value': 450
    }
]

我需要添加（求和）和可能的任何其他数学运算，例如计算平均值出现在其中的同名对象。类似的东西： -

[
    {
        'name': 'P1',
        'value': 300
    },
    {
        'name': 'P2',
        'value': 200
    },
    {
        'name': 'P3',
        'value': 450
    }
]

感谢我能得到的任何帮助。

提前致谢！

Answer 1

首先遍历数组并将'name'推送到另一个对象的属性中。如果属性存在，则将“value”添加到属性的值，否则将属性初始化为“value”。构建此对象后，遍历属性并将它们推送到另一个数组。

以下是一些代码：

var obj = [
    { 'name': 'P1', 'value': 150 },
    { 'name': 'P1', 'value': 150 },
    { 'name': 'P2', 'value': 200 },
    { 'name': 'P3', 'value': 450 }
];

var holder = {};

obj.forEach(function (d) {
    if(holder.hasOwnProperty(d.name)) {
       holder[d.name] = holder[d.name] + d.value;
    } else {       
       holder[d.name] = d.value;
    }
});

var obj2 = [];

for(var prop in holder) {
    obj2.push({name: prop, value: holder[prop]});   
}

console.log(obj2);

希望这有帮助。

Answer 2

您可以使用Array.reduce()在每次迭代期间累积结果。

var arr = [{'name':'P1','value':150},{'name':'P1','value':150},{'name':'P2','value':200},{'name':'P3','value':450}];

var result = arr.reduce(function(acc, val){
    var o = acc.filter(function(obj){
        return obj.name==val.name;
    }).pop() || {name:val.name, value:0};
    
    o.value += val.value;
    acc.push(o);
    return acc;
},[]);

console.log(result);

Answer 3

这是一种适用于您对象中任意数量的属性的方法（“对象”在两个对象中必须相同，才能将它们“分组”）。它涉及遍历数组并将其简化为包含键值对的对象。新对象的每个键都是所有属性值的字符串，因此，如果对象键已经存在，则知道它是重复的，这意味着您可以将对象的当前值添加到存储的对象中。最后，您可以使用Object.values()来获取减少键值对对象中设置的累积对象：

const arr = [{'name':'P1','value':150},{'name':'P1','value':150},{'name':'P2','value':200},{'name':'P3','value':450}];

const res = Object.values(arr.reduce((acc, {value, ...r}) => {
  const key = Object.entries(r).join('-');
  acc[key] = (acc[key]  || {...r, value: 0});
  return (acc[key].value += value, acc);
}, {}));
console.log(res);

如果您不支持Object.entries()，则可以将此呼叫替换为JSON.stringify()：

const arr = [{'name':'P1','value':150},{'name':'P1','value':150},{'name':'P2','value':200},{'name':'P3','value':450}];


const res = Object.values(arr.reduce((acc, {value, ...r}) => {
  const key = JSON.stringify(r);
  acc[key] = (acc[key]  || {...r, value: 0});
  return (acc[key].value += value, acc);
}, {}));
console.log(res);

Answer 4

我为尼克·帕森斯先生定制了答案（谢谢你的想法）。如果您需要对多个键值求和。

var arr = [{'name':'P1','value':150,'apple':10},{'name':'P1','value':150,'apple':20},{'name':'P2','value':200,'apple':30},{'name':'P3','value':450,'apple':40}];

var res = Object.values(arr.reduce((acc, {value,apple , ...r}) => {
  var key = Object.entries(r).join('-');
  acc[key] = (acc[key]  || {...r, apple:0,value: 0});
  return (acc[key].apple += apple, acc[key].value += value, acc);
}, {}));

console.log(res);

Answer 5

由于某种原因，当我运行@Vignesh Raja的代码时，我获得了“和”，但也重复了项。因此，我必须按照以下说明删除重复项。

原始数组：

arr=[{name: "LINCE-01", y: 70}, 
 {name: "LINCE-01", y: 155},
 {name: "LINCE-01", y: 210},
 {name: "MIRAFLORES-03", y: 232},
 {name: "MIRAFLORES-03", y: 267}]

使用@VigneshRaja的代码：

var result = arr.reduce(function(acc, val){
    var o = acc.filter(function(obj){
        return obj.name==val.name;
    }).pop() || {name:val.name, y:0};

    o.y += val.y;
    acc.push(o);
    return acc;
},[]);

console.log(result);

第一个结果：

result: [{name: "LINCE-01", y: 435},
 {name: "LINCE-01", y: 435},
 {name: "LINCE-01", y: 435},
 {name: "MIRAFLORES-03", y: 499},
 {name: "MIRAFLORES-03", y: 499}]

删除重复项：

var finalresult = result.filter(function(itm, i, a) {
                            return i == a.indexOf(itm);
                        });
console.log(finalresult);

最后，我得到了我所想的：

finalresult = [{name: "LINCE-01", y: 435},
 {name: "MIRAFLORES-03", y: 657}]

此致

Answer 6

我想还有另一种干净的解决方案

Start-Process -FilePath "java.exe"  -ArgumentList '-jar fitnesse-standalone.jar -p 9090'

Answer 7

(function () {
var arr = [
    {'name': 'P1', 'age': 150},
    {'name': 'P1', 'age': 150},
    {'name': 'P2', 'age': 200},
    {'name': 'P3', 'age': 450}
];
var resMap = new Map();
var result = [];
arr.map((x) => {
    if (!resMap.has(x.name))
        resMap.set(x.name, x.age);
    else
        resMap.set(x.name, (x.age + resMap.get(x.name)));
})
resMap.forEach((value, key) => {
    result.push({
        name: key,
        age: value
    })
})
console.log(result);
})();

Answer 8

let ary = [
    {
        'key1': 'P1',
        'key2': 150
    },
    {
        'key1': 'P1',
        'key2': 150
    },
    {
        'key1': 'P2',
        'key2': 200
    },
    {
        'key1': 'P3',
        'key2': 450
    }
]

结果数组let newAray = []

for (let index = 0; index < ary.length; index++) {
        // console.log(ary[index].key1);
    
        for (let index2 = index + 1; index2 < ary.length; index2++) {
    
            if (ary[index2].key1 == ary[index].key1) {
                console.log('match');
                ary[index].key2 += ary[index2].key2;
                newAry = ary.filter( val => val !== ary[index2]);
    
                newAry = ary.filter(function (e) {
                    return  e !== ary[index2];
                });
    
            }
        }
    }
console.log(newAry)

Answer 9

let arr = [
        {'name':'P1','value':150,'apple':10},
        {'name':'P1','value':150,'apple':20},
        {'name':'P2','value':200,'apple':30},
        {'name':'P2','value':600,'apple':30},
        {'name':'P3','value':450,'apple':40}
];

let obj = {}

arr.forEach((item)=>{
   if(obj[item.name]){
        obj[item.name].value = obj[item.name].value + item.value
   }else{
       obj[item.name] = item
   }
})

let valuesArr = Object.values(obj)
console.log(valuesArr);

输出

<块引用>

[ { name: "P1", value: 300, apple: 10 },
{ name: "P2", value: 800, 苹果: 30 },
{ name: "P3", value: 450, apple: 40 } ]

Answer 10

let data= [
                {
                    'key1': 'P1',
                    'key2': 150
                },
                {
                    'key1': 'P1',
                    'key2': 150
                },
                {
                    'key1': 'P2',
                    'key2': 200
                },
                {
                    'key1': 'P3',
                    'key2': 450
                }
            ]
            
             var holder = []
                        data.forEach( index => {
                                const data = holder.find( i => i.key1=== index.key1)
                                if(!data){
                                    holder.push({key1:index.key1,key2:index.key2})
                                }else{
                                    data.key2 = parseInt(data.key2) + parseInt(index.key2)
                                }
                        });
            
            console.log(holder);

对对象数组中的类似键求和

10 个答案: