对象数组中具有相同对象属性b的javascript对象属性a值之和

如何获取对象的javascript数组，例如：

my objArr = [
{key:Mon Sep 23 2013 00:00:00 GMT-0400, val:42},
{key:Mon Sep 24 2013 00:00:00 GMT-0400, val:78},
{key:Mon Sep 25 2013 00:00:00 GMT-0400, val:23},
{key:Mon Sep 23 2013 00:00:00 GMT-0400, val:54}]

并通过求和值来合并重复的键。 为了得到这样的东西：

my reducedObjArr = [
{key:Mon Sep 23 2013 00:00:00 GMT-0400, val:96},
{key:Mon Sep 24 2013 00:00:00 GMT-0400, val:78},
{key:Mon Sep 25 2013 00:00:00 GMT-0400, val:23}]

我已尝试迭代并添加到新数组，但这不起作用：

var reducedObjArr = [];
var item = null, key = null;
for(var i=0; i<objArr.length; i++) {
   item=objArr[i];
   key = Object.keys(item)[0];
   item=item[key];

   if(!result[key]){
       result[key] = item;
   }else{
       result[key] += item;}
   }a

var reducedobjar=[]；
var item=null，key=null；
对于（var i=0；i
var targetObj={}；
对于（变量i=0；i

您应该使用其
.key
属性将未找到的每个对象分配给结果

如果找到它，则需要添加它的
.val

var temp = {};
var obj = null;
for(var i=0; i < objArr.length; i++) {
   obj=objArr[i];

   if(!temp[obj.key]) {
       temp[obj.key] = obj;
   } else {
       temp[obj.key].val += obj.val;
   }
}
var result = [];
for (var prop in temp)
    result.push(temp[prop]);

var-temp={}；
var obj=null；
对于（变量i=0；i


另外，部分问题是您正在重用
项
变量来引用
.key
的值，因此您丢失了对对象的引用。
这里有一个替代方法，但与的方法类似，它是重用原始数组，而不是创建新数组或其他对象。排序可能不是必需的，并且将稍微慢一点，但它可以被移除

Javascript

function reduceMyObjArr(arr) {
    var temp = {},
        index;

    for (index = arr.length - 1; index >= 0; index -= 1) {
        key = arr[index].key;
        if (temp.hasOwnProperty(key)) {
            arr[temp[key]].val += arr[index].val;
            arr.splice(index, 1);
        } else {
            temp[key] = index;
        }
    }

    arr.sort(function (a, b) {
        if (a.key === b.key) {
            return 0;
        }

        if (a.key < b.key) {
            return -1;
        }

        return 1;
    });

    return arr;
}

var myObjArr = [{
    key: "Mon Sep 23 2013 00: 00: 00 GMT - 0400",
    val: 42
}, {
    key: "Mon Sep 24 2013 00: 00: 00 GMT - 0400",
    val: 78
}, {
    key: "Mon Sep 25 2013 00: 00: 00 GMT - 0400",
    val: 23
}, {
    key: "Mon Sep 23 2013 00: 00: 00 GMT - 0400",
    val: 54
}];

reduceMyObjArr(myObjArr);

console.log(myObjArr);

函数约简myobjar（arr）{
var temp={}，
指数
对于（索引=arr.length-1；索引>=0；索引-=1）{
key=arr[index].key；
if（临时hasOwnProperty（键））{
arr[temp[key]].val+=arr[index].val；
阵列拼接（索引1）；
}否则{
临时[键]=索引；
}
}
arr.sort（函数（a，b）{
如果（a.key==b.key）{
返回0；
}
如果（a键


和一个将此（有或没有排序）与接受的答案进行比较的。您可以通过扩展数据集来改进性能测试。
您可以直接使用和，而不是使用for循环和推送值：


let objArr=[
{关键字：2013年9月23日星期一00:00:00 GMT-0400'，val:42}，
{关键字：2013年9月24日星期一00:00:00 GMT-0400'，val:78}，
{关键字：2013年9月25日星期一00:00:00 GMT-0400'，val:23}，
{关键字：2013年9月23日星期一00:00:00 GMT-0400'，val:54}
];
//首先，使用reduce将数据转换为地图
让计数=对象减少（（上一个，当前）=>{
让count=prev.get（curr.key）| 0；
上一设置（当前键、当前值+计数）；
返回上一个；
}，新地图（））；
//然后，将counts对象映射回数组
让reducedObjArr=[…计数].map（[key，value]）=>{
返回{key，value}
})
console.log（reducedobjar）；
您还可以尝试使用javascript linq框架，它与sql语句完全相同，它以更少的编写代码和有效的方式提供所需的输出，并在linq.js中找到


var objArr=
[
{键：'2013年9月23日星期一00:00:00 GMT-0400'，val:42}，
{key:'Mon Sep 24 2013 00:00:00 GMT-0400'，val:78}，
{键：'2013年9月25日星期一00:00:00 GMT-0400'，val:23}，
{键：'2013年9月23日星期一00:00:00 GMT-0400'，val:54}
];
var aggregatedObject=Enumerable.From（objArr）
.GroupBy（“$.key”），空，
功能（键，g）{
返回{
钥匙：钥匙，
捐款：总额（$.val）
}
})
.ToArray（）；
console.log（聚合对象）；
您可以使用哈希表按
键进行分组


var数组=[{key:'Mon-Sep 23 2013 00:00:00 GMT-0400'，val:42}，{key:'Mon-Sep 24 2013 00:00:00 GMT-0400'，val:78}，{key:'Mon-Sep 25 2013 00:00:00 GMT-0400'，val:23}，{key:'Mon Sep 23 2013 00:00:00 GMT-0400'，val:54}]，
分组=[]；
array.forEach（函数（o）{
如果（！此[o.key]）{
this[o.key]={key:o.key，val:0}；
分组。按下（此[o.键]）；
}
此[o.key].val+=o.val；
}，Object.create（null））；
console.log（分组）；
.as console wrapper{max height:100%！important；top:0；}
最近我需要一个类似的实现，我使用了一个使用reduce函数的家伙提供的类似解决方案。几天后，我想自己实现类似的东西，结果如下

const users = [
        { id: 1, name: 'ernest', spent: 40 }, 
        { id: 2, name: 'ernest', spent: 40 },
        { id: 3, name: 'astrit', spent: 22 },
        { id: 4, name: 'astrit', spent: 2956 },
        { id: 5, name: 'astrit', spent: 22 }, 
        { id: 6, name: 'besart', spent: 40 }, 
        { id: 7, name: 'besart', spent: 100}, 
        { id: 8, name: 'besart', spent: 4000 }
    ];

        const sum = [];

        users.forEach(el => {
            if(sum.length === 0){
                delete el.id;
                sum.push(el);
            }    
            else
            {
                const get = () => {
                    for(let i = 0; i < sum.length; i++){
                        if(sum[i].name === el.name ){
                            return { stat: true, id: i };
                        }
                    }
                }

                let i = get();
                if(i){
                    sum[i.id].spent += el.spent;
                }
                else
                {
                    delete el.id;
                    sum.push(el);
                }
            }
        });

        console.log(sum);

试试这个，应该会有帮助

var arr1 = [
    { name: 'besart', value: 12 },
    { name: 'astrit', value: 10 },
    { name: 'astrit', value: 10 },
    { name: 'besar', value: 18 },
    { name: 'besar', value: 3 },
    { name: 'astrit', value: 3 },
    { name: 'besart', value: 3 },
    { name: 'besart', value: 10 },
    { name: 'besar', value: 0 },
];

var arr2 = [];
var emri = "";
var value = 0;
for(var i = 0;i<arr1.length;i++){
    emri=arr1[0].name;
    value+=arr1[0].value;
    for(var j=1;j<arr1.length;j++){
        if(emri==arr1[j].name){
            value+=arr1[j].value;
            arr1.splice(j,1);
            j--;
        }
    }
    arr1.splice(0,1);
    arr2[i] = {name:emri,value:value};
    value=0;
}
console.log(arr2);

比贴在别处更简单


const objArr=[
{key:“2013年9月23日星期一00:00:00 GMT-0400”，val:42}，
{key:“2013年9月24日星期一00:00:00 GMT-0400”，val:78}，
{key:“2013年9月25日星期一00:00:00 GMT-0400”，val:23}，
{关键字：“2013年9月23日星期一00:00:00 GMT-0400”，val:54}]；
常量输出=对象减少（（累加器，当前）=>{
让日期=cur.key；
let found=累加器.find（elem=>elem.key==日期）
如果（找到）found.val+=cur.val；
else蓄能器。推动（cur）；
回流蓄能器；
}, []);
console.log（输出）
函数mergeDuplicatesBy（数组、getKey、mergeWith）{
常量buff={}
forEach（函数（arrayElement）{
const key=getKey（数组元素）
常量alreadyExistingVal=buff[键]
如果（已存在VAL）{
buff[key]=mergeWith（alreadyExistingVal，arrayElement）
}否则{
buff[键]=数组元素
}
})
返回对象值（buff）
}
梅格斯比(
啊,，
x=>x.name，
（x，y）=>（{name:x.name，foo:x.foo+y.foo}）
)
可以使用对象来存储每个键的值


让arr=[{key:'周一2013年9月23日00
[ { name: 'ernest', spent: 80 }, { name: 'astrit', spent: 3000 }, { name: 'besart', spent: 4140 } ]

var arr1 = [
    { name: 'besart', value: 12 },
    { name: 'astrit', value: 10 },
    { name: 'astrit', value: 10 },
    { name: 'besar', value: 18 },
    { name: 'besar', value: 3 },
    { name: 'astrit', value: 3 },
    { name: 'besart', value: 3 },
    { name: 'besart', value: 10 },
    { name: 'besar', value: 0 },
];

var arr2 = [];
var emri = "";
var value = 0;
for(var i = 0;i<arr1.length;i++){
    emri=arr1[0].name;
    value+=arr1[0].value;
    for(var j=1;j<arr1.length;j++){
        if(emri==arr1[j].name){
            value+=arr1[j].value;
            arr1.splice(j,1);
            j--;
        }
    }
    arr1.splice(0,1);
    arr2[i] = {name:emri,value:value};
    value=0;
}
console.log(arr2);

 var arr2 = [];
    var emri = "";
    var value = 0;
    var i=1;
    var j=0;

while(arr1.length != 0){
        emri = arr1[0].name;
        if(emri == arr1[i].name){
            value+=arr1[i].value;
            arr1.splice(i,1);
            i--;
        }
        i++;
        if(i==arr1.length){
            value+=arr1[0].value;
            i=1;
            arr2[j]={name:emri,value:value};
            j++;
            value=0;
            arr1.splice(0,1);
        }
    }