Nodejs Utililty Methods Array Group By

Array.prototype.groupBy = function(callback) {
    let obj = {}
    this.forEach(el => {
        let index = callback(el)
        if (!obj.hasOwnProperty(index)) {
            obj[index] = []
        obj[index].push(el)
    })
...

Array.prototype.groupBy = function(callback){
var results = {};
  this.forEach(function (el){
    var key = callback(el);
    if (key in results === false) {
      results[key] = [];
    results[key].push(el);
 });
...

Array.prototype.groupBy = function(callback){
    this.reduce() 
var result{}
this.forEach(v, i, arr) = function(){}
v, i, arr
Array.prototype.groupBy = function(callback){ 
  var evens = Array.groupBy.forEach([9])
  if(Array.groupBy %2 === 0){
...

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);
...

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;
...

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])] = [
...

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
  }, {})
...

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);
...

function groupByArray(array, groupFunction) {
    var map = {}
    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(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};
  });