Javascript: How to filter an object array and sum result

Question

I have an object array:

var example = [{a:1, b:2, c:3}, {a:4, b:5, c:6}, {a:7, b:8, c:9}]

I am trying to add all values that don't correspond with c.

• I've managed to filter out a row, which wasn't what I was after, with console.log(test.filter(x => x.c > 3));

• I've also tried a data query and chaining .ne("c") to it, but this didn't work.

I have managed to find the sum of an object array, but it doesn't omit the elements corresponding with "c". The code for that is:

var example = [{a:1, b:2, c:3}, {a:4, b:5, c:6}, {a:7, b:8, c:9}]
var sumobjects
sumobjects = example.map(y => Object.keys(y).reduce((x,z) => x + y[z], 0));
const reducer = (accumulator, currentValue) => accumulator + currentValue;
const sumexample = sumobjects.reduce(reducer)
console.log(sumexample);

My current code is looking like this:

var example = [{a:1, b:2, c:3}, {a:4, b:5, c:6}, {a:7, b:8, c:9}]
function filtration (arr) {

 var filteredsum = 0
 for (let i = 0; i < arr.length; i++) {
 for (let j = 0; j < arr[i].length; j++) {
 for(let k = 0; k < arr[i][j].length && arr[i][j] !== "c"; k++)
            filteredsum += arr[i][j]            
        }
    }   
 return(filteredsum);
}
console.log(filtration(example));

The answer should be one single number, being 27.

The code I currently have is outputting 0, so I figure that instead of omitting the property "c" from the sum, it's finding c and then omitting the entire object from the object array.

EDIT: The object array above is a simplified version of the object array I'm actually working with. The actual object array is not limited to the properties a, b and c. It has about 350 different properties. So code that adds a and b and c by actually stating a, b and c isn't going to be a good option for me.

Answer 1

You can do like this if you just want to exclude "c" property but include sum of values of all properties of objects of the array.

var example = [{a:1, b:2, c:3}, {a:4, b:5, c:6}, {a:7, b:8, c:9}];

let sum = 0; 
example.forEach(obj => {
    for (let property in obj) {
        if(property !== "c")
        sum += obj[property];
    }
})

Answer 2

You can use the function below and pass the keys to omit as an array of string to the second parameter. The first parameter will be the list itself.

const sumWithout = (list, without) => {
  return list.reduce((acc, item) => {
    for (let [key, value] of Object.entries(item)) {
      if(!without.includes(key)){
        acc = Number(value) + acc;
      }
    }

    return acc;
  }, 0)
}

console.log(sumWithout(yourList, ['c', 'foo', '...' ]));

Answer 3

You already have the code to add all properties.
Object.keys(y) get you all properties of the object, the reducer is using them with y[z] assuming z='a' it's like doing y.a: the solution is to filter unwanted properties before the reduce

The change is on this line:

var sumobjects = example.map(y => Object.keys(y).filter(k=>k!=='c').reduce((x,z) => x + y[z], 0));

Here the complete code:

var example = [{a:1, b:2, c:3}, {a:4, b:5, c:6}, {a:7, b:8, c:9}]
var sumobjects = example.map(y => Object.keys(y).filter(k=>k!=='c').reduce((x,z) => x + y[z], 0));
const reducer = (accumulator, currentValue) => accumulator + currentValue;
const sumexample = sumobjects.reduce(reducer)
console.log(sumexample);

If you want to exclude more than one property you can create an array with properties to avoid:
var exceptedProperties = ["c","d"];
The change is

var sumobjects = example.map(y => Object.keys(y).filter(k=>!exceptedProperties.some(p=>p===k)).reduce((x,z) => x + y[z], 0));

Complete code:

var example = [{a:1, b:2, c:3, d:4}, {a:4, b:5, c:6, d:7}, {a:7, b:8, c:9, d:10}]
var sumobjects = example.map(y => Object.keys(y).filter(k=>!exceptedProperties.some(p=>p===k)).reduce((x,z) => x + y[z], 0));
const reducer = (accumulator, currentValue) => accumulator + currentValue;
const sumexample = sumobjects.reduce(reducer)
console.log(sumexample);

Answer 4

var example = [{a:1, b:2, c:3}, {a:4, b:5, c:6}, {a:7, b:8, c:9}]

var res = example.reduce((acc, curr) => {
    return acc = acc + curr.a + curr.b
}, 0)

You can reduce initial array that way and get desired result. It takes 0 as initial value and then add a and b properties of each element of the array

Answer 5

If you want the sum of all "a" and "b" properties excluding "c", you can do it like this:

var example = [{a:1, b:2, c:3}, {a:4, b:5, c:6}, {a:7, b:8, c:9}];

let totalSum = 0;
example.forEach(obj => {
    let objSum = obj.a + obj.b;
    totalSum += objSum;
})

Answer 6

Try

let example = [{a:1, b:2, c:3}, {a:4, b:5, c:6}, {a:7, b:8, c:9}];

let keys = Object.keys(example[0]).filter(k=> k!='c');
let sumObj = obj => keys.reduce((a,c)=> a + obj[c],0);

let totalSum = example.reduce((a,c)=> a + sumObj(c), 0);

console.log(totalSum);

Answer 7

If you want to add every property of your objects except for some, you can filter them out by looping through the properties and checking whether they are the ones you are trying to avoid and act accordingly.

This code works regardless of the number of the properties and their names. You can expand it to filter out more properties if you like.

var example = [{a:1, b:2, c:3}, {a:4, b:5, c:6}, {a:7, b:8, c:9}]

const result = example.reduce((acc, cur) => {
  for (let el in cur) {
    acc += el !== "c" ? cur[el] : 0
  }
  return acc; 
}, 0)
console.log(result)

Answer 8

Hope this helps.

var example = [{a:1, b:2, c:3}, {a:4, b:5, c:6}, {a:7, b:8, c:9}];
var sum = 0;
for(var i = 0; i < example.length; i++){
    for(var j = 0; j < Object.keys(example[i]).length; j++){
        if(Object.keys(example[i])[j] != "c"){
        sum +=  parseInt(example[i][Object.keys(example[i])[j]]);
        }
    }
}

console.log(sum);

Answer 9

Ok, I figured out, that your reallife object is huge. You can do that:

const result = example.map(item => {
    // first way (extract a, b)
    const {a, b} = item;
    // second way (omit c)
    const {c, ...rest} = item;
})

So what happens here. If its easier to you to extract properties from initial object then you go first way and return {a, b}. If its better to omit properties then you go second way and return rest

So Ill take second way and continue the code

const res = example.map(item => {
    const {c, ...rest} = item;
    return rest
}).reduce((acc, curr) => {
    Object.values(curr).forEach(value => acc = acc + value);
    return acc
}, 0);

If you choose first way - reducer will be the same, only map return will be different.