कुंजी द्वारा वस्तुओं की एक सरणी को समूह कैसे करें

Question

क्या किसी को ऑब्जेक्ट की कुंजी द्वारा समूह की एक सरणी बनाने के लिए (अगर संभव हो तो भी) रास्ता पता है तो समूह के आधार पर वस्तुओं का एक नया सरणी बनाएं? उदाहरण के लिए, मेरे पास कार वस्तुओं की एक सरणी है:

var cars = [
    {
        'make': 'audi',
        'model': 'r8',
        'year': '2012'
    }, {
        'make': 'audi',
        'model': 'rs5',
        'year': '2013'
    }, {
        'make': 'ford',
        'model': 'mustang',
        'year': '2012'
    }, {
        'make': 'ford',
        'model': 'fusion',
        'year': '2015'
    }, {
        'make': 'kia',
        'model': 'optima',
        'year': '2012'
    },
];

मैं उन कार वस्तुओं का एक नया सरणी बनाना चाहता हूं जो इसके द्वारा समूहीकृत हैं make:

var cars = {
    'audi': [
        {
            'model': 'r8',
            'year': '2012'
        }, {
            'model': 'rs5',
            'year': '2013'
        },
    ],

    'ford': [
        {
            'model': 'mustang',
            'year': '2012'
        }, {
            'model': 'fusion',
            'year': '2015'
        }
    ],

    'kia': [
        {
            'model': 'optima',
            'year': '2012'
        }
    ]
}

Comments

क्या आपने देखा groupBy?

— एसएलके

आपका परिणाम मान्य नहीं है।

— नीना स्कोल्ज़

क्या ऑब्जेक्ट के बजाय मैप प्राप्त करने के लिए समान दृष्टिकोण है?

— एंड्रिया बर्गांज़ो

Answer 1

टिमो का जवाब है कि मैं यह कैसे करूंगा। सरल _.groupBy, और समूहीकृत संरचना में वस्तुओं में कुछ दोहराव की अनुमति दें।

हालाँकि ओपी ने डुप्लीकेट makeचाबियों को हटाने के लिए भी कहा । यदि आप सभी रास्ते जाना चाहते हैं:

var grouped = _.mapValues(_.groupBy(cars, 'make'),
                          clist => clist.map(car => _.omit(car, 'make')));

console.log(grouped);

पैदावार:

{ audi:
   [ { model: 'r8', year: '2012' },
     { model: 'rs5', year: '2013' } ],
  ford:
   [ { model: 'mustang', year: '2012' },
     { model: 'fusion', year: '2015' } ],
  kia: [ { model: 'optima', year: '2012' } ] }

यदि आप अंडरस्कोर.जे का उपयोग करके ऐसा करना चाहते थे, तो ध्यान दें कि इसका संस्करण _.mapValuesकहा जाता है _.mapObject।

Answer 2

सादे जावास्क्रिप्ट में, आप Array#reduceएक वस्तु के साथ उपयोग कर सकते हैं

var cars = [{ make: 'audi', model: 'r8', year: '2012' }, { make: 'audi', model: 'rs5', year: '2013' }, { make: 'ford', model: 'mustang', year: '2012' }, { make: 'ford', model: 'fusion', year: '2015' }, { make: 'kia', model: 'optima', year: '2012' }],
    result = cars.reduce(function (r, a) {
        r[a.make] = r[a.make] || [];
        r[a.make].push(a);
        return r;
    }, Object.create(null));

console.log(result);

.as-console-wrapper { max-height: 100% !important; top: 0; }

Comments

मैं कैसे resultपरिणाम कर सकता हूँ ?

— मुनीर एलफैसी

आप Object.entriesकुंजी / मान जोड़े के माध्यम से प्रविष्टियों को और लूप के साथ ले जा सकते हैं ।

— नीना स्कोल्ज़

क्या एक makeबार समूहीकृत किए गए डेटा सेट से हटाने का कोई तरीका है? यह अतिरिक्त जगह ले रहा है।

— मर्क्यूरियल

हाँ, रेस्ट इन ऑब्जेक्ट डिस्ट्रक्ट्यूरिंग ।

— नीना शुल्ज़

R और r क्या है? क्या यह मान लेना सही होगा कि r संचायक और एक currentValue है?

— उमर

Answer 3

आप ढूंढ रहे हैं _.groupBy()।

यदि आवश्यक हो तो वस्तुओं से आपके द्वारा समूहीकृत की जा रही संपत्ति को हटाया जाना चाहिए:

var cars = [{'make':'audi','model':'r8','year':'2012'},{'make':'audi','model':'rs5','year':'2013'},{'make':'ford','model':'mustang','year':'2012'},{'make':'ford','model':'fusion','year':'2015'},{'make':'kia','model':'optima','year':'2012'},];

var grouped = _.groupBy(cars, function(car) {
  return car.make;
});

console.log(grouped);

<script src='https://cdn.jsdelivr.net/lodash/4.17.2/lodash.min.js'></script>

---

एक बोनस के रूप में, आपको ES6 तीर फ़ंक्शन के साथ भी अच्छे सिंटैक्स मिलते हैं:

const grouped = _.groupBy(cars, car => car.make);

Comments

और अगर आप इसे अभी भी कम चाहते हैं var grouped = _.groupBy(cars, 'make');, तो किसी फ़ंक्शन की आवश्यकता नहीं है, अगर एक्सेसर एक साधारण संपत्ति का नाम है।

— जोनाथन यूनिस

क्या '_' के लिए खड़ा है?

— एड्रियन ग्रेज्वेक्यूस्की

@ AdrianGrzywaczewski यह नाम-रिक्ति 'लॉश' या 'अंडरस्कोर' के लिए डिफ़ॉल्ट सम्मेलन था। अब जब कि लिब्राब्रिज मॉड्यूलर है तो इसकी आवश्यकता नहीं रह जाती है। npmjs.com/package/lodash.groupby

— vilsbole

और मैं परिणाम में कैसे अंतर कर सकता हूं?

— लुइस एंटोनियो पेस्टाना

Answer 4

लघु संस्करण es6 में एक निश्चित कुंजी द्वारा वस्तुओं की एक सरणी समूह के लिए:

result = array.reduce((h, obj) => Object.assign(h, { [obj.key]:( h[obj.key] || [] ).concat(obj) }), {})

अब संस्करण:

result = array.reduce(function(h, obj) {
  h[obj.key] = (h[obj.key] || []).concat(obj);
  return h; 
}, {})

ऐसा प्रतीत होता है कि मूल प्रश्न पूछते हैं कि कैसे कारों को समूह बनायें, लेकिन प्रत्येक समूह में मेक को छोड़ दें। तो जवाब इस तरह दिखेगा:

result = cars.reduce((h, {model,year,make}) => {
  return Object.assign(h, { [make]:( h[make] || [] ).concat({model,year})})
}, {})

Comments

यह निश्चित रूप से es5 नहीं है

— शिनिगामी

इसका काम करता है! क्या कोई भी इस कार्य को कम कर सकता है?

— जीवन

मुझे आपके दोनों उत्तर पसंद आए, लेकिन मैं देखता हूं कि वे दोनों "मेक" फील्ड को प्रत्येक "मेक" एरे के सदस्य के रूप में प्रदान करते हैं। मैंने आपके आधार पर एक उत्तर प्रदान किया है जहाँ वितरित आउटपुट अपेक्षित आउटपुट से मेल खाता है। धन्यवाद!

— डैनियल वूकसोविच

Answer 5

यहां आपका अपना स्वयं का groupByफ़ंक्शन है जो कोड का सामान्यीकरण है: https://github.com/you-dont-need/You-Dont-Need-Lodash-Underscore

function groupBy(xs, f) {
  return xs.reduce((r, v, i, a, k = f(v)) => ((r[k] || (r[k] = [])).push(v), r), {});
}

const cars = [{ make: 'audi', model: 'r8', year: '2012' }, { make: 'audi', model: 'rs5', year: '2013' }, { make: 'ford', model: 'mustang', year: '2012' }, { make: 'ford', model: 'fusion', year: '2015' }, { make: 'kia', model: 'optima', year: '2012' }];

const result = groupBy(cars, (c) => c.make);
console.log(result);

Answer 6

var cars = [{
  make: 'audi',
  model: 'r8',
  year: '2012'
}, {
  make: 'audi',
  model: 'rs5',
  year: '2013'
}, {
  make: 'ford',
  model: 'mustang',
  year: '2012'
}, {
  make: 'ford',
  model: 'fusion',
  year: '2015'
}, {
  make: 'kia',
  model: 'optima',
  year: '2012'
}].reduce((r, car) => {

  const {
    model,
    year,
    make
  } = car;

  r[make] = [...r[make] || [], {
    model,
    year
  }];

  return r;
}, {});

console.log(cars);

Answer 7

मैं REAL GROUP BYJS Arrays उदाहरण के लिए यही कार्य यहाँ करना चाहता हूँ

const inputArray = [ 
    { Phase: "Phase 1", Step: "Step 1", Task: "Task 1", Value: "5" },
    { Phase: "Phase 1", Step: "Step 1", Task: "Task 2", Value: "10" },
    { Phase: "Phase 1", Step: "Step 2", Task: "Task 1", Value: "15" },
    { Phase: "Phase 1", Step: "Step 2", Task: "Task 2", Value: "20" },
    { Phase: "Phase 2", Step: "Step 1", Task: "Task 1", Value: "25" },
    { Phase: "Phase 2", Step: "Step 1", Task: "Task 2", Value: "30" },
    { Phase: "Phase 2", Step: "Step 2", Task: "Task 1", Value: "35" },
    { Phase: "Phase 2", Step: "Step 2", Task: "Task 2", Value: "40" }
];

var outObject = inputArray.reduce(function(a, e) {
  // GROUP BY estimated key (estKey), well, may be a just plain key
  // a -- Accumulator result object
  // e -- sequentally checked Element, the Element that is tested just at this itaration

  // new grouping name may be calculated, but must be based on real value of real field
  let estKey = (e['Phase']); 

  (a[estKey] ? a[estKey] : (a[estKey] = null || [])).push(e);
  return a;
}, {});

console.log(outObject);

Answer 8

आप फ़ंक्शन के अंदर ऑब्जेक्ट को संशोधित करने का प्रयास कर सकते हैं जिसे _.groupBy func द्वारा पुनरावृत्ति कहा जाता है। ध्यान दें कि स्रोत सरणी उसके तत्वों को बदल देती है!

var res = _.groupBy(cars,(car)=>{
    const makeValue=car.make;
    delete car.make;
    return makeValue;
})
console.log(res);
console.log(cars);

Comments

हालांकि यह कोड प्रश्न को हल कर सकता है, जिसमें यह भी बताया गया है कि यह समस्या कैसे और क्यों हल करती है, इससे आपकी पोस्ट की गुणवत्ता को बेहतर बनाने में मदद मिलेगी। याद रखें कि आप भविष्य में पाठकों के लिए सवाल का जवाब दे रहे हैं, न कि केवल उस व्यक्ति से जो अब पूछ रहा है! कृपया स्पष्टीकरण जोड़ने के लिए अपना उत्तर संपादित करें, और इस बात का संकेत दें कि क्या सीमाएँ और मान्यताएँ लागू होती हैं।

— Makyen

वांछित परिणाम प्राप्त करने के लिए केवल एक बार सरणी के माध्यम से जाने के बाद से यह मेरे लिए सबसे अच्छा उत्तर लगता है। makeसंपत्ति को निकालने के लिए किसी अन्य फ़ंक्शन का उपयोग करने की आवश्यकता नहीं है , और यह अधिक पठनीय भी है।

— कार्म

Answer 9

यह एक साधारण forलूप के साथ भी संभव है :

 const result = {};

 for(const {make, model, year} of cars) {
   if(!result[make]) result[make] = [];
   result[make].push({ model, year });
 }

Comments

और शायद और भी तेज, और सरल। मैंने आपके स्निपेट को थोड़ा और अधिक गतिशील होने के लिए विस्तारित किया है क्योंकि मेरे पास एक db तालिका से फ़ील्ड की एक लंबी सूची थी जिसे मैं टाइप करने के लिए नहीं करता था। यह भी ध्यान दें कि आपको कॉन्स्ट को लेट से बदलने की आवश्यकता होगी। for ( let { TABLE_NAME, ...fields } of source) { result[TABLE_NAME] = result[TABLE_NAME] || []; result[TABLE_NAME].push({ ...fields }); }

— एड्रियन

टीआईएल, धन्यवाद! medium.com/@mautayro/...

— एड्रियन

Answer 10

उन मामलों के लिए जहां कुंजी शून्य हो सकती है और हम उन्हें दूसरों के रूप में समूहित करना चाहते हैं

var cars = [{'make':'audi','model':'r8','year':'2012'},{'make':'audi','model':'rs5','year':'2013'},{'make':'ford','model':'mustang','year':'2012'},{'make':'ford','model':'fusion','year':'2015'},{'make':'kia','model':'optima','year':'2012'},
            {'make':'kia','model':'optima','year':'2033'},
            {'make':null,'model':'zen','year':'2012'},
            {'make':null,'model':'blue','year':'2017'},

           ];


 result = cars.reduce(function (r, a) {
        key = a.make || 'others';
        r[key] = r[key] || [];
        r[key].push(a);
        return r;
    }, Object.create(null));

Answer 11

एक विधि बनाएं, जिसका पुन: उपयोग किया जा सके

Array.prototype.groupBy = function(prop) {
      return this.reduce(function(groups, item) {
        const val = item[prop]
        groups[val] = groups[val] || []
        groups[val].push(item)
        return groups
      }, {})
    };

फिर नीचे आप किसी भी मापदंड से समूह बना सकते हैं

const groupByMake = cars.groupBy('make');
        console.log(groupByMake);

var cars = [
    {
        'make': 'audi',
        'model': 'r8',
        'year': '2012'
    }, {
        'make': 'audi',
        'model': 'rs5',
        'year': '2013'
    }, {
        'make': 'ford',
        'model': 'mustang',
        'year': '2012'
    }, {
        'make': 'ford',
        'model': 'fusion',
        'year': '2015'
    }, {
        'make': 'kia',
        'model': 'optima',
        'year': '2012'
    },
];
  //re-usable method
Array.prototype.groupBy = function(prop) {
	  return this.reduce(function(groups, item) {
		const val = item[prop]
		groups[val] = groups[val] || []
		groups[val].push(item)
		return groups
	  }, {})
	};
  
 // initiate your groupBy. Notice the recordset Cars and the field Make....
  const groupByMake = cars.groupBy('make');
		console.log(groupByMake);
    
    //At this point we have objects. You can use Object.keys to return an array

Answer 12

ईएस 6 के साथ-साथ प्रोटोटाइप संस्करण भी। मूल रूप से यह एक संचायक और वर्तमान आइटम में पारित करने के लिए कम फ़ंक्शन का उपयोग करता है, जो तब कुंजी में पारित के आधार पर आपके "समूहबद्ध" सरणियों के निर्माण के लिए इसका उपयोग करता है। कम करने का भीतरी हिस्सा जटिल लग सकता है, लेकिन अनिवार्य रूप से यह देखने के लिए परीक्षण कर रहा है कि क्या ऑब्जेक्ट में पास की कुंजी मौजूद है और यदि यह तब खाली सरणी नहीं बनाता है और मौजूदा आइटम को उस नए बनाए गए सरणी में जोड़ देता है अन्यथा प्रसार का उपयोग कर रहा है ऑपरेटर वर्तमान कुंजी सरणी के सभी ऑब्जेक्ट में पास होता है और वर्तमान आइटम को जोड़ता है। आशा है कि यह किसी की मदद करता है !.

Array.prototype.groupBy = function(k) {
  return this.reduce((acc, item) => ((acc[item[k]] = [...(acc[item[k]] || []), item]), acc),{});
};

const projs = [
  {
    project: "A",
    timeTake: 2,
    desc: "this is a description"
  },
  {
    project: "B",
    timeTake: 4,
    desc: "this is a description"
  },
  {
    project: "A",
    timeTake: 12,
    desc: "this is a description"
  },
  {
    project: "B",
    timeTake: 45,
    desc: "this is a description"
  }
];

console.log(projs.groupBy("project"));

Answer 13

आप array#forEach()इस तरह से विधि का उपयोग भी कर सकते हैं :

const cars = [{ make: 'audi', model: 'r8', year: '2012' }, { make: 'audi', model: 'rs5', year: '2013' }, { make: 'ford', model: 'mustang', year: '2012' }, { make: 'ford', model: 'fusion', year: '2015' }, { make: 'kia', model: 'optima', year: '2012' }];

let newcars = {}

cars.forEach(car => {
  newcars[car.make] ? // check if that array exists or not in newcars object
    newcars[car.make].push({model: car.model, year: car.year})  // just push
   : (newcars[car.make] = [], newcars[car.make].push({model: car.model, year: car.year})) // create a new array and push
})

console.log(newcars);

Answer 14

function groupBy(data, property) {
  return data.reduce((acc, obj) => {
    const key = obj[property];
    if (!acc[key]) {
      acc[key] = [];
    }
    acc[key].push(obj);
    return acc;
  }, {});
}
groupBy(people, 'age');

Answer 15

बस यह एक कोशिश करो यह मेरे लिए ठीक काम करता है।

let grouped = _.groupBy(cars, 'make');

Comments

बिना संदर्भ संदर्भित: _ परिभाषित नहीं है - आपको स्पष्ट होना चाहिए कि आपके समाधान को इसे हल करने के लिए सिर्फ 3 पार्टी लाइब्रेरी स्थापित करने की आवश्यकता है।

— मेटकांगफू

क्षमा करें, मुझे लगता है कि हर एक जानता है। _ खड़ा है और ज्यादातर लॉश लिब के लिए उपयोग किया जाता है। इसलिए आपको लॉश का उपयोग करने की आवश्यकता है। कृपया प्रश्न पढ़ें ताकि आपको पता चल जाए कि वह दर्ज कराने के लिए कह रहा है। खैर धन्यवाद। मुझे यह याद रहेगा। और lib लिखना कभी न भूलें।

— agravat.in

Answer 16

मैंने प्रत्येक समाधान के प्रदर्शन का परीक्षण करने के लिए एक बेंचमार्क बनाया जो बाहरी पुस्तकालयों का उपयोग नहीं करता है।

JSBen.ch

reduce()विकल्प, @Nina स्कोल्ज़ द्वारा पोस्ट की गई इष्टतम एक लगता है।

Answer 17

मुझे @metakunfu उत्तर पसंद आया, लेकिन यह अपेक्षित आउटपुट प्रदान नहीं करता है। यहां एक अपडेट किया गया है जो अंतिम JSON पेलोड में "मेक" से छुटकारा दिलाता है।

var cars = [
    {
        'make': 'audi',
        'model': 'r8',
        'year': '2012'
    }, {
        'make': 'audi',
        'model': 'rs5',
        'year': '2013'
    }, {
        'make': 'ford',
        'model': 'mustang',
        'year': '2012'
    }, {
        'make': 'ford',
        'model': 'fusion',
        'year': '2015'
    }, {
        'make': 'kia',
        'model': 'optima',
        'year': '2012'
    },
];

result = cars.reduce((h, car) => Object.assign(h, { [car.make]:( h[car.make] || [] ).concat({model: car.model, year: car.year}) }), {})

console.log(JSON.stringify(result));

आउटपुट:

{  
   "audi":[  
      {  
         "model":"r8",
         "year":"2012"
      },
      {  
         "model":"rs5",
         "year":"2013"
      }
   ],
   "ford":[  
      {  
         "model":"mustang",
         "year":"2012"
      },
      {  
         "model":"fusion",
         "year":"2015"
      }
   ],
   "kia":[  
      {  
         "model":"optima",
         "year":"2012"
      }
   ]
}

Answer 18

लॉश / fp के साथ आप _.flow()एक कुंजी द्वारा उस 1 समूहों के साथ एक फ़ंक्शन बना सकते हैं , और फिर प्रत्येक समूह को मैप कर सकते हैं, और प्रत्येक आइटम के लिए एक कुंजी छोड़ सकते हैं:

const { flow, groupBy, mapValues, map, omit } = _;

const groupAndOmitBy = key => flow(
  groupBy(key),
  mapValues(map(omit(key)))
);

const cars = [{ make: 'audi', model: 'r8', year: '2012' }, { make: 'audi', model: 'rs5', year: '2013' }, { make: 'ford', model: 'mustang', year: '2012' }, { make: 'ford', model: 'fusion', year: '2015' }, { make: 'kia', model: 'optima', year: '2012' }];

const groupAndOmitMake = groupAndOmitBy('make');

const result = groupAndOmitMake(cars);

console.log(result);

.as-console-wrapper { max-height: 100% !important; top: 0; }

<script src='https://cdn.jsdelivr.net/g/lodash@4(lodash.min.js+lodash.fp.min.js)'></script>

Answer 19

यदि आप अपने सभी क्षेत्रों में लिखना नहीं चाहते हैं तो @Jonas_Wilms द्वारा उत्तर पर निर्माण करें:

    var result = {};

    for ( let { first_field, ...fields } of your_data ) 
    { 
       result[first_field] = result[first_field] || [];
       result[first_field].push({ ...fields }); 
    }

मैंने कोई बेंचमार्क नहीं बनाया, लेकिन मेरा मानना ​​है कि लूप के लिए उपयोग करना इस उत्तर में सुझाए गए किसी भी चीज़ से अधिक कुशल होगा ।

Answer 20

const reGroup = (list, key) => {
    const newGroup = {};
    list.forEach(item => {
        const newItem = Object.assign({}, item);
        delete newItem[key];
        newGroup[item[key]] = newGroup[item[key]] || [];
        newGroup[item[key]].push(newItem);
    });
    return newGroup;
};

const animals = [
  {
    type: 'dog',
    breed: 'puddle'
  },
  {
    type: 'dog',
    breed: 'labradoodle'
  },
  {
    type: 'cat',
    breed: 'siamese'
  },
  {
    type: 'dog',
    breed: 'french bulldog'
  },
  {
    type: 'cat',
    breed: 'mud'
  }
];
console.log(reGroup(animals, 'type'));

const cars = [
  {
      'make': 'audi',
      'model': 'r8',
      'year': '2012'
  }, {
      'make': 'audi',
      'model': 'rs5',
      'year': '2013'
  }, {
      'make': 'ford',
      'model': 'mustang',
      'year': '2012'
  }, {
      'make': 'ford',
      'model': 'fusion',
      'year': '2015'
  }, {
      'make': 'kia',
      'model': 'optima',
      'year': '2012'
  },
];

console.log(reGroup(cars, 'make'));

Answer 21

इसके साथ टाइपस्क्रिप्ट में ऑब्जेक्ट की समूहीकृत सरणी:

groupBy (list: any[], key: string): Map<string, Array<any>> {
    let map = new Map();
    list.map(val=> {
        if(!map.has(val[key])){
            map.set(val[key],list.filter(data => data[key] == val[key]));
        }
    });
    return map;
});

Comments

जैसा कि आप प्रत्येक कुंजी की खोज करते हैं, यह अक्षम दिखता है। खोज में O (n) की सबसे अधिक जटिलता है।

— लेकिप

Answer 22

मैं इसे बिना किसी निर्भरता / जटिलता के केवल शुद्ध सरल js के साथ लिखना पसंद करता हूं।

const mp = {}
const cars = [
  {
    model: 'Imaginary space craft SpaceX model',
    year: '2025'
  },
  {
    make: 'audi',
    model: 'r8',
    year: '2012'
  },
  {
    make: 'audi',
    model: 'rs5',
    year: '2013'
  },
  {
    make: 'ford',
    model: 'mustang',
    year: '2012'
  },
  {
    make: 'ford',
    model: 'fusion',
    year: '2015'
  },
  {
    make: 'kia',
    model: 'optima',
    year: '2012'
  }
]

cars.forEach(c => {
  if (!c.make) return // exit (maybe add them to a "no_make" category)

  if (!mp[c.make]) mp[c.make] = [{ model: c.model, year: c.year }]
  else mp[c.make].push({ model: c.model, year: c.year })
})

console.log(mp)

Answer 23

यहाँ इसका एक और समाधान है। के रूप में अनुरोध किया।

मैं कार वस्तुओं की एक नई सारणी बनाना चाहता हूँ जिसे मेक द्वारा समूहीकृत किया गया हो:

function groupBy() {
  const key = 'make';
  return cars.reduce((acc, x) => ({
    ...acc,
    [x[key]]: (!acc[x[key]]) ? [{
      model: x.model,
      year: x.year
    }] : [...acc[x[key]], {
      model: x.model,
      year: x.year
    }]
  }), {})
}

आउटपुट:

console.log('Grouped by make key:',groupBy())

Answer 24

यहाँ Java में कलेक्टरों (समूह) से प्रेरित एक समाधान है:

function groupingBy(list, keyMapper) {
  return list.reduce((accummalatorMap, currentValue) => {
    const key = keyMapper(currentValue);
    if(!accummalatorMap.has(key)) {
      accummalatorMap.set(key, [currentValue]);
    } else {
      accummalatorMap.set(key, accummalatorMap.get(key).push(currentValue));
    }
    return accummalatorMap;
  }, new Map());
}

यह एक मैप ऑब्जेक्ट देगा।

// Usage

const carMakers = groupingBy(cars, car => car.make);