কী দ্বারা কীভাবে অবজেক্টগুলির একটি অ্যারে গ্রুপ করা যায়

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?

— স্লাকস

আপনার ফলাফল বৈধ নয়।

— নিনা শোল্জ

কোনও জিনিসের পরিবর্তে মানচিত্র পাওয়ার জন্য কি একই রকম দৃষ্টিভঙ্গি রয়েছে?

— Andrea Bergonzo

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' } ] }

আপনি এই ব্যবহার Underscore.js, নোট করতে চেয়েছিলেন যে তার সংস্করণ _.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 হ'ল সঞ্চালক এবং বর্তমানের মান?

— ওমর

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');তবে অ্যাকসেসর একটি সাধারণ সম্পত্তি নাম হিসাবে যদি কোনও ফাংশনের প্রয়োজন হয় না।

— জোনাথন ইউনিস

'_' বলতে কী বোঝায়?

— অ্যাড্রিয়ান গ্রিজিওয়াকজেউস্কি

@ অ্যাড্রিয়ানগ্রজিওয়াকজেউস্কি এটি নাম-ফাঁকা 'লোডাশ' বা 'আন্ডারস্কোর' এর জন্য পূর্বনির্ধারিত সম্মেলন ছিল। এখন যে গ্রন্থাগারগুলি মডিউল হয়ে গেছে তার আর প্রয়োজন নেই। npmjs.com/package/lodash.groupby

— ভিলসোলে

এবং আমি কীভাবে ফলাফলটিতে ইন্টেরেশন করতে পারি?

— লুইস আন্তোনিও পেস্তানা

Answer 4

এস in-তে একটি নির্দিষ্ট কী দ্বারা অবজেক্টগুলির একটি অ্যারে গ্রুপ করার জন্য সংক্ষিপ্ত সংস্করণ:

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

এটি অবশ্যই এস 5 নয়

— শিনিগামি

এটি ঠিক কাজ করে !. কেউ কি এর কার্যকারিতা হ্রাস করতে পারে?

— জীবন

আমি আপনার উভয় উত্তর পছন্দ করেছি, কিন্তু আমি উভয়ই প্রতিটি "মেক" অ্যারের সদস্য হিসাবে "মেক" ফিল্ড সরবরাহ করি। আমি আপনার উপর ভিত্তি করে একটি উত্তর সরবরাহ করেছি যেখানে বিতরণ আউটপুটটি প্রত্যাশিত আউটপুটটির সাথে মেলে। ধন্যবাদ!

— ড্যানিয়েল ভুকাসোভিচ

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 BYজেএস অ্যারে উদাহরণের জন্য এখানে এই টাস্কের মতো ঠিক রেখে যাব

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

এবং সম্ভবত দ্রুত এবং সহজতর। আমি আপনার স্নিপেটটি কিছুটা আরও গতিশীল হতে প্রসারিত করেছি যেহেতু আমি টাইপ করতে চাই না এমন একটি ডিবি টেবিল থেকে ক্ষেত্রগুলির একটি দীর্ঘ তালিকা ছিল Also এছাড়াও নোট করুন যে আপনাকে লেটের সাথে প্রতিস্থাপন করতে হবে। for ( let { TABLE_NAME, ...fields } of source) { result[TABLE_NAME] = result[TABLE_NAME] || []; result[TABLE_NAME].push({ ...fields }); }

— Adrien

তিল, ধন্যবাদ! medium.com/@mautayro/...

— Adrien

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

প্রোটোটাইপ সংস্করণ ES6 পাশাপাশি ব্যবহার করে। মূলত এটি একটি সঞ্চালক এবং বর্তমান আইটেমটি পাস করার জন্য হ্রাস ফাংশনটি ব্যবহার করে, যা পরে পাস করা কী এর উপর ভিত্তি করে আপনার "গোষ্ঠীভুক্ত" অ্যারেগুলি তৈরি করতে এটি ব্যবহার করে। হ্রাসের অভ্যন্তরীণ অংশটি জটিল দেখাতে পারে তবে মূলত এটি পরীক্ষা করে দেখা হচ্ছে যে কোনও বস্তুতে পাসের কীটি বিদ্যমান রয়েছে এবং তা যদি খালি অ্যারে তৈরি করে না এবং বর্তমান আইটেমটিকে নতুনভাবে তৈরি অ্যারেটিতে সংযুক্ত করে অন্যথায় স্প্রেড ব্যবহার করে অপারেটর বর্তমান কী অ্যারে সমস্ত বস্তু পাস এবং বর্তমান আইটেম সংযোজন। আশা করি এটি কাউকে সাহায্য করবে!

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

আনকড রেফারেন্স এরিয়ার: _ সংজ্ঞায়িত করা হয়নি - আপনার স্পষ্ট হওয়া উচিত যে এটি সমাধান করার জন্য আপনার সমাধানটির জন্য একটি তৃতীয় পক্ষের লাইব্রেরি ইনস্টল করা প্রয়োজন।

— metakungfu

দুঃখিত, আমি মনে করি সবাই জানে। _ স্ট্যান্ড এবং বেশিরভাগ লোডাশ লিবের জন্য ব্যবহৃত হয়। সুতরাং আপনার লোডাশ ব্যবহার করা উচিত। দয়া করে প্রশ্নটি পড়ুন যাতে আপনি জানতে পারবেন যে সে লডাশ চাইছে। ভালো ধন্যবাদ. আমি এটা মনে রাখব। এবং lib লিখতে ভুলবেন না।

— agravat.in

Answer 16

বাহ্যিক লাইব্রেরি ব্যবহার না করে এমন প্রতিটি সমাধানের কার্যকারিতা পরীক্ষা করার জন্য আমি একটি মানদণ্ড তৈরি করেছি।

JSBen.ch

reduce()বিকল্প, @Nina স্কল্জ অ্যান্ড পোস্ট করেছে অনুকূল এক বলে মনে হয়।

Answer 17

আমি @ মেটাকুনফু উত্তরটি পছন্দ করেছি তবে এটি প্রত্যাশিত আউটপুটটি সরবরাহ করে না। এখানে একটি আপডেট রয়েছে যা চূড়ান্ত জেএসওএন পেলোডের "মেক" থেকে মুক্তি পাবে।

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

লডাশ / এফপি দিয়ে আপনি _.flow()একটি কী দ্বারা 1st ম গ্রুপের সাথে একটি ফাংশন তৈরি করতে পারেন , এবং তারপরে প্রতিটি গ্রুপকে মানচিত্র করুন এবং প্রতিটি আইটেম থেকে একটি কী বাদ দিতে পারেন:

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

আপনি যদি আপনার সমস্ত ক্ষেত্রে টাইপ করতে না চান তবে @ জোনাস_ উইলমসের উত্তরে বিল্ডিং :

    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

আপনি প্রতিটি কীটির জন্য অনুসন্ধান করার সময় এটি অদৃশ্য দেখাচ্ছে। অনুসন্ধানে সম্ভবত ও (এন) এর জটিলতা রয়েছে।

— লিউইকিপ

Answer 22

আমি কোন নির্ভরতা / জটিলতা কেবল খাঁটি সরল জেএস সহ এটি লিখতে পছন্দ করি।

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

এখানে জাভাতে সংগ্রাহকগণের কাছ থেকে অনুপ্রাণিত একটি সমাধান দেওয়া হয়েছে ()

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