ES6 Optimal way to count occurrences of array elements as values in array of objects

Question

I have a set of data like this:

[
  {
    name:'Bart',
    classes:['Maths','Philosophy','Music']
  },
  {
    name:'Lisa',
    classes: ['Maths','Literature','Music']
  },
  {
    name:'Maggie',
    classes: ['Quantum Physics','Literature']
  }
]

And I would like to output an array like

[ 
  { "name": "Maths", "count": 2 },
  { "name": "Music", "count": 2 },
  { "name": "Literature", "count": 2 },
  { "name": "Quantum Physics", "count": 1 },
  { "name": "Philosophy", "count": 1 }
]

What would be the optimal way to do it in ES6? Thanks in advance!

Edit: my attempt

    let mappedArray = Array.map(item => item.classes)
    let flattenedArray = mappedArray.reduce(
      ( accumulator, currentValue ) => accumulator.concat(currentValue),
      []
    );
    let countedArray = flattenedArray.reduce(function (allClasses, item) {
      if (item in allClasses) {
        allClasses[item]++;
      }
      else {
        allClasses[item] = 1;
      }
      return allClasses;
    }, {});
    return countedArray

What do you think is the optimal way to do this? Please post a minimal reproducible example of your attempt and say specifically why you don't think it's the optimal way. — Luca Kiebel
– Luca Kiebel, Commented Aug 22, 2018 at 10:38

Ankit Agarwal · Accepted Answer · 2018-08-22 10:43:22Z

4

You can use Array.reduce() with forEach() loop inside reduce() to loop over the classes array:

var arr = [{
    name: 'Bart',
    classes: ['Maths', 'Philosophy', 'Music']
  },
  {
    name: 'Lisa',
    classes: ['Maths', 'Literature', 'Music']
  },
  {
    name: 'Maggie',
    classes: ['Quantum Physics', 'Literature']
  }
];

var res = arr.reduce((acc, obj) => {
  var classes = obj.classes;
  classes.forEach((subject) => {
      var exist = acc.find(({name}) => subject === name);
      if (exist) {
        exist.count++;
      } else {
        acc.push({
          name: subject,
          count: 1
        });
      }
  });
  return acc;
}, []);
console.log(res);

answered Aug 22, 2018 at 10:43

Ankit Agarwal

30.8k5 gold badges41 silver badges63 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Ashish Ranjan · Accepted Answer · 2018-08-22 10:46:36Z

Using Array reduce I have first created a temporary Object which looks:

{
  "Maths": 2,
  "Philosophy": 1,
  "Music": 2,
  "Literature": 2,
  "Quantum Physics": 1
}

Then I have looped over the temporaryObject to generate the desired output

var originalData = [
  {
    name:'Bart',
    classes:['Maths','Philosophy','Music']
  },
  {
    name:'Lisa',
    classes: ['Maths','Literature','Music']
  },
  {
    name:'Maggie',
    classes: ['Quantum Physics','Literature']
  }
]

var tempCount = originalData.reduce((acc, elem) => {
  elem.classes.forEach((eachClass) => {
    if (eachClass in acc) {
      acc[eachClass] ++;
    }
    else {
      acc[eachClass] = 1;
    }
  })
  return acc
}, {});

console.log(tempCount)

var desiredResult = [];
for (var eachSub in tempCount) {
  if (tempCount.hasOwnProperty(eachSub)) {
    desiredResult.push({name: eachSub, count: tempCount[eachSub] })
  }
}

console.log(desiredResult)

FZs · Accepted Answer · 2018-08-22 11:12:33Z

1

Try this code:

    var names=[],
    counts=[],
    output=[],
    input=[
      {
        name:'Bart',
        classes:['Maths','Philosophy','Music']
      },
      {
        name:'Lisa',
        classes: ['Maths','Literature','Music']
      },
      {
        name:'Maggie',
        classes: ['Quantum Physics','Literature']
      }
    ]
    for(i in input){
        for(j in input[i].classes){
            if (!names.includes(input[i].classes[j])){
                names.push(input[i].classes[j])
                counts.push(0)
            }
            counts[names.indexOf(input[i].classes[j])]++
        }
    }
    for(k in names){
        output.push({name:names[k],count:counts[k]})
    }
    console.log(output)

edited Aug 22, 2018 at 11:12

answered Aug 22, 2018 at 11:06

FZs

18.8k13 gold badges47 silver badges56 bronze badges

Comments

brk · Accepted Answer · 2018-08-22 11:25:23Z

1

You can use reduce & concat

let x = [{
    name: 'Bart',
    classes: ['Maths', 'Philosophy', 'Music']
  },
  {
    name: 'Lisa',
    classes: ['Maths', 'Literature', 'Music']
  },
  {
    name: 'Maggie',
    classes: ['Quantum Physics', 'Literature']
  }
]

let m = x.reduce(function(acc, curr) {
 // this will return an array of 'Maths', 'Philosophy', 'Music'...] 
 // & it will have duplicate elements
  return acc.concat(curr.classes)
}, []).reduce(function(acc, curr) {
  // again using reduce function to return an object key as subject name & count
  if (!acc.hasOwnProperty(curr)) {
    acc[curr] = 1
  } else {
    acc[curr] += 1
  }
  return acc;
}, {});
console.log(m)

answered Aug 22, 2018 at 11:25

brk

50.3k10 gold badges59 silver badges85 bronze badges

Comments

jonatjano · Accepted Answer · 2018-08-22 10:45:48Z

0

you can do :

let data = [
  {
    name:'Bart',
    classes:['Maths','Philosophy','Music']
  },
  {
    name:'Lisa',
    classes: ['Maths','Literature','Music']
  },
  {
    name:'Maggie',
    classes: ['Quantum Physics','Literature']
  }
]

let result = {}

for (let i of data) i.classes.forEach(j => {if (!result[j]) result[j]=0; result[j]++})

console.log(result)

it may not be optimal but seems quite good

same but more human readable

for (let student of data) {
  student.classes.forEach(clas => {
    if (!result[clas]) {
      result[clas]=0
    }
    result[clas]++
  })
}

// using "clas" because "class" is a reserved javascript word

answered Aug 22, 2018 at 10:45

jonatjano

3,7681 gold badge17 silver badges20 bronze badges

Collectives™ on Stack Overflow

ES6 Optimal way to count occurrences of array elements as values in array of objects

5 Answers 5

Comments

Comments

Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

5 Answers 5

Comments

Comments

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related