Nodejs Array Group By groupBy(groupFunction)

Here you can find the source of groupBy(groupFunction)

Method Source Code

function groupByArray(array, groupFunction) {
    var map = {}// w w  w  .  j  a  v  a 2 s.co  m
    array.forEach(
    function forEachFunction(item, index, array) {
        var groupName = groupFunction(item, index, array)
        if (map[groupName]) map[groupName].push(item)
        else map[groupName] = [item]
    })
    return map
}

Array.prototype.groupBy = function groupBy(groupFunction) {
    return groupByArray(this, groupFunction)
}

Related

  1. groupBy(fieldName)
    Array.prototype.groupBy = function (fieldName) {
        if (this.some(item => item.hasOwnProperty(fieldName))) {
            let uniqVal = this.map(item => item[fieldName]).filter((value, item, array) => array.indexOf(value) === item);
            let tempObj = {};
            uniqVal.map(item => tempObj[item] = []);
            this.forEach(item => {
                for (let name in tempObj) {
                    if (item[fieldName] == name) {
                        tempObj[name].push(item);
    ...
    
  2. groupBy(fieldkey,fieldsums,fn)
    Array.prototype.groupBy=function(fieldkey,fieldsums,fn){
      var groups = _.groupBy(this,function(item){
        return item[fieldkey];
      });
      async.map(_.keys(groups)
        ,function(key,callback){
          var value = groups[key];
          var r = {};
          r[fieldkey] = key;
    ...
    
  3. groupBy(fn)
    Array.prototype.groupBy = function (fn) {
      var result = {
      };
      for (var i = 0; i < this.length; i++)
        try {
          if (!result[fn(this[i])])
            result[fn(this[i])] = [
    ...
    
  4. groupBy(fn)
    Array.prototype.groupBy = function(fn) {
      if (!fn) return this.groupBy(x => x)
      return this.reduce((acc, x) => {
        if (acc[fn(x)]) return acc
        acc[fn(x)] = this.filter(i => {
          return fn(x) === fn(i)
        })
        return acc
      }, {})
    ...
    
  5. groupBy(funcProp)
    Array.prototype.groupBy = function (funcProp) {
      return this.reduce(function (accumulator, value) {
        (accumulator[funcProp(value)] = accumulator[funcProp(value)] || []).push(value);
        return accumulator;
      }, {});
    };
    Array.prototype.orderBy = function (funcProp, desc = false) {
      return this.sort((a, b) => {
        var aValue = funcProp(a);
    ...
    
  6. groupBy(hash)
    Array.prototype.groupBy = function(hash){
      var _hash = hash ? hash : function(o){return o;};
      var _map = {};
      var put = function(map, key, value){
        if (!map[_hash(key)]) {
            map[_hash(key)] = {};
            map[_hash(key)].group = [];
            map[_hash(key)].key = key;
        map[_hash(key)].group.push(value); 
      this.map(function(obj){
        put(_map, obj, obj);
      });
      return Object.keys(_map).map(function(key){
        return {key: _map[key].key, group: _map[key].group};
      });
    
  7. groupBy(prop)
    Array.prototype.groupBy = function(prop) {
      return this.reduce(function(groups, item) {
        var val = item[prop];
        groups[val] = groups[val] || [];
        groups[val].push(item);
        return groups;
      }, {});
    let students = [
    ...
    
  8. groupBy(selector, comparer)
    Array.prototype.groupBy = function (selector, comparer) {
        var grp = [];
        var l = this.length;
        comparer = comparer || EqualityComparer;
        selector = selector || Selector;
        for (var i = 0; i < l; i++) {
            var k = selector(this[i]);
            var g = grp.first(function (u) { return comparer(u.key, k); });
            if (!g) {
    ...