Get count from Array of arrays

You can try below logic:

var data = [[{name: "Good"}],[{name: "Good"}, {name:"Excellent"}],[{name: "Good"}, {name:"Excellent"}, {name:"Wow"}],[{name: "Good"}, {name:"Excellent"}, {name:"Wow"}],[{name:"Excellent"}],[{name:"Excellent"}]]

var nData = [];

(data || []).forEach( e => {
  (e || []).forEach(ei => {
    var i = (index = nData.findIndex(d => d.name === ei.name)) >=0 ? index : nData.length;
    nData[i] = {
      name: ei.name,
      count : (nData[i] && nData[i].count ? nData[i].count : 0)+1
    }
  });
});

console.log(nData);

Hope this helps!

You can use reduce, then convert the result into an array of objects:

const counts = remarks.reduce((result, list) => {
  list.forEach(remark => {
    result[remark.name] = (result[remark.name] || 0) + 1;
  });
}, {});
const finalResult = [];
for (let name in counts) {
  finalResult.push({name, count: counts[name]});
}

You could achieve this pretty easily by:

1) Flattening the nested array into 1 single level array.

2) Iterating over the flat array and create a "count map" by using Array.prototype.reduce

For example:

const remarks = [
  [{
    name: 'Good'
  }],
  [{
    name: 'Good'
  }, {
    name: 'Excellent'
  }],
  [{
    name: 'Good'
  }, {
    name: 'Excellent'
  }, {
    name: 'Wow'
  }],
  [{
    name: 'Good'
  }, {
    name: 'Excellent'
  }, {
    name: 'Wow'
  }],
  [{
    name: 'Excellent'
  }],
  [{
    name: 'Excellent'
  }]
]

const flatten = arr => arr.reduce((accum, el) => accum.concat(el), [])
const map = flatten(remarks).reduce((accum, el) => {
  if (accum[el.name]) {
    accum[el.name] += 1;
  } else {
    accum[el.name] = 1;
  }
  return accum;
}, {});

console.log(map)

First find the counts using reduce than pass that to another function to get the desired view structure:

const Good = 1,
      Excellent = 2,
      Wow = 3;

const remarks = [
  [{name: Good}],
  [{name: Good}, {name:Excellent}],
  [{name: Good}, {name:Excellent}, {name:Wow}],
  [{name: Good}, {name:Excellent}, {name:Wow}],
  [{name:Excellent}],
  [{name:Excellent}]
];

/*
[{name: Good, count: 4} {name: Excellent, count: 5}, {name:Wow, count:2}]
*/

function counts(remarks) {
  return remarks.flat().reduce((acc, v) => {
    const name = v.name;
    let count = acc[name] || 0;
    return {
    ...acc,
    [name]: count + 1
    }
  }, {});
}

function view(counts) {
   return Object.keys(counts).map(key => {
     let count = counts[key];
     return { name: key, count };
   })
}

console.log(view(counts(remarks)));

Any time you are making a smaller set of data, or transforming data, in JavaScript reduce should be the first method you attempt to use. In this case, you may want to pair it with an indexer (hence preloading with an array of index and an array of result).

This works in one pass without needing to know the name values up front.

const remarks = [
  [{name: "Good"}],
  [{name: "Good"}, {name: "Excellent"}],
  [{name: "Good"}, {name: "Excellent"}, {name: "Wow"}],
  [{name: "Good"}, {name: "Excellent"}, {name: "Wow"}],
  [{name: "Excellent"}],
  [{name: "Excellent"}]
];

const stats = remarks.reduce((p,c) => (
  c.forEach( ({name}) => {
    if(!p[0].hasOwnProperty(name)){
      p[1].push({name:name,count:0});
      p[0][name] = p[1].length - 1;
    }
    p[1][p[0][name]].count++;
  }),p),[{},[]])[1];
    
console.log(stats);

A slightly more concise and definitely less readable approach (but it's worth to mention) could be:

const remarks = [
  [{ name: "Good" }],
  [{ name: "Good" }, { name: "Excellent" }],
  [{ name: "Good" }, { name: "Excellent" }, { name: "Wow" }],
  [{ name: "Good" }, { name: "Excellent" }, { name: "Wow" }],
  [{ name: "Excellent" }],
  [{ name: "Excellent" }]
];

const stats = Object.entries(
                remarks
                  .flat()
                  .reduce((acc, {name}) => (acc[name] = -~acc[name], acc), {})))
              ).map(([name, count]) => ({ name, count }));


console.log(stats);

It uses the comma operator in the reducer to returns the accumulator; and the bitwise operator NOT to create a counter without the needs to initialize the object upfront with all the names.

const flattenedRemarks = _.flatten(remarks);

const groupedRemarks = _.groupBy(flattenedRemarks, (remark) => remark.name);

const remarkCounts = _.mapValues(groupedRemarks, (group) => group.length);

const data = {
    "mchale": {
        "classes":["ESJ030", "SCI339"], // get the length
        "faculty":["Hardy", "Vikrum"]   // get the length
     },
    "lawerence":{
        "classes":["ENG001"],  // get the length
        "faculty":["Speedman", "Lee", "Lazenhower"] // get the length
     }
};

const count = Object.keys(data).map(campusName => {
  const campus = data[campusName];
  return Object.keys(campus).map(key => campus[key].length).reduce((p, c) => p + c, 0);
}).reduce((p, c) => p + c, 0);
console.log(count);