সম্পত্তি মান দ্বারা বস্তুর একটি অ্যারে বাছাই করা


1330

আমি এজেএক্স ব্যবহার করে নীচের জিনিসগুলি পেয়েছি এবং সেগুলি একটি অ্যারেতে সঞ্চয় করেছি:

var homes = [
    {
        "h_id": "3",
        "city": "Dallas",
        "state": "TX",
        "zip": "75201",
        "price": "162500"
    }, {
        "h_id": "4",
        "city": "Bevery Hills",
        "state": "CA",
        "zip": "90210",
        "price": "319250"
    }, {
        "h_id": "5",
        "city": "New York",
        "state": "NY",
        "zip": "00010",
        "price": "962500"
    }
];

কেবল জাভাস্ক্রিপ্ট ব্যবহার করে priceসম্পত্তি দ্বারা আরোহী বা অবতরণ ক্রমে কী কীভাবে আমি একটি ফাংশন তৈরি করব ?


দ্রুততম উপায় হ'ল isomorphic সারণি -অ্যারে মডিউলটি যা ব্রাউজার এবং নোড উভয় ক্ষেত্রেই স্থানীয়ভাবে কাজ করে, যে কোনও ধরণের ইনপুট, গণিত ক্ষেত্র এবং কাস্টম সাজানোর আদেশকে সমর্থন করে।
লয়েড

উত্তর:


1673

আরোহী ক্রমে দাম অনুসারে বাছাই করুন:

homes.sort(function(a, b) {
    return parseFloat(a.price) - parseFloat(b.price);
});

অথবা ES6 সংস্করণের পরে:

homes.sort((a, b) => parseFloat(a.price) - parseFloat(b.price));

কিছু ডকুমেন্টেশন এখানে পাওয়া যাবে


182
আপনি string1.localeCompare(string2)স্ট্রিং তুলনার জন্য ব্যবহার করতে পারেন
ব্র্যাডভিডো

62
মাথায় রাখুন যে localeCompare()ক্ষেত্রে সংবেদনশীল । আপনি যদি কেস সংবেদনশীল চান তবে আপনি এটি ব্যবহার করতে পারেন (string1 > string2) - (string1 < string2)। পার্থক্য গণনা করতে বুলিয়ান মানগুলি 0 এবং 1 এর পূর্ণসংখ্যায় জোর করা হয়।
ডন কার্কবি

2
@ পয়েন্টের আপডেটের জন্য ধন্যবাদ, আমি মনে করি এই সমস্যাটি চালাচ্ছিল না, তবে সম্ভবত গত কয়েক বছর ধরে আচরণটি বদলেছে। নির্বিশেষে, localeCompare()ডকুমেন্টেশনটি দেখায় যে আপনি কেস সংবেদনশীলতা, সংখ্যাসমূহ বাছাই করা এবং অন্যান্য বিকল্প চান কিনা তা আপনি স্পষ্টভাবে বলতে পারবেন।
ডন

2
@ sg28 আমি মনে করি আপনি MDN ব্যাখ্যা ভুল বুঝেছেন। এটি বলে না যে সাজানোর কাজটি নির্ভরযোগ্য নয় , এটি বলে যে এটি স্থিতিশীল নয় । আমি বুঝতে পারি কেন এটি বিভ্রান্তিকর হতে পারে তবে এটি দাবি করার জন্য এটি উপযুক্ত নয় যে এটি উপযুক্ত নয়। বাছাইকরণ অ্যালগরিদমগুলির প্রসঙ্গে, স্থিতির শব্দটির একটি নির্দিষ্ট অর্থ রয়েছে - তালিকার "সমান" উপাদানগুলি ইনপুট হিসাবে একই ক্রমে সাজানো হয় । এটি সম্পূর্ণরূপে কোডের ধারণার সাথে সম্পর্কিত নয় যা অস্থির (যেমন এখনও ব্যবহারের জন্য প্রস্তুত নয়)।
স্টোবর

1
আপনি যদি একটি নির্দিষ্ট স্ট্রিং মান অনুসারে বাছাই করতে চান তবে উদাহরণস্বরূপ যে শহরটি আপনি ব্যবহার করতে পারেন: this.homes.sort ((বর্তমান, পরবর্তী) => current কারেন্ট.সিটি.লোকেলকম্পার (নেক্সটসিটি) {) রিটার্ন করুন;
জর্জি ভালভার্ট

675

এখানে একটি আরও নমনীয় সংস্করণ, যা আপনাকে পুনরায় ব্যবহারযোগ্য সাজানোর ক্রিয়া তৈরি করতে এবং যে কোনও ক্ষেত্র অনুসারে বাছাই করতে দেয়।

const sort_by = (field, reverse, primer) => {

  const key = primer ?
    function(x) {
      return primer(x[field])
    } :
    function(x) {
      return x[field]
    };

  reverse = !reverse ? 1 : -1;

  return function(a, b) {
    return a = key(a), b = key(b), reverse * ((a > b) - (b > a));
  }
}


//Now you can sort by any field at will...

const homes=[{h_id:"3",city:"Dallas",state:"TX",zip:"75201",price:"162500"},{h_id:"4",city:"Bevery Hills",state:"CA",zip:"90210",price:"319250"},{h_id:"5",city:"New York",state:"NY",zip:"00010",price:"962500"}];

// Sort by price high to low
console.log(homes.sort(sort_by('price', true, parseInt)));

// Sort by city, case-insensitive, A-Z
console.log(homes.sort(sort_by('city', false, (a) =>  a.toUpperCase()
)));


7
নিকব - আপনি কোডটি ভুলভাবে পড়ছেন। sort_byও (1) এ চলে এবং একটি তালিকার আইটেমগুলির তুলনা করার জন্য বিল্ট-ইন সাজান (ও (এন লগ এন)) দ্বারা ব্যবহৃত একটি ফাংশন দেয়। মোট জটিলতা হ'ল O (n লগ এন) * ও (1) যা হ্রাস করে O (n লগ এন), বা তাত্ক্ষণিক ধরণের হিসাবে।
ট্রিপটিচ

1
আমার এই সমস্যাটির সাথে একটি সমস্যা হ'ল বিপরীত = মিথ্যা দিয়ে, এটি সংখ্যাগুলি 1,2,3,4 হিসাবে বাছাই করবে ... তবে স্ট্রিংস z, y, x ...
অ্যাবি

4
একটি ছোট বর্ধন:var key = primer ? function (x) { return primer(x[field]); } : function (x) { return x[field]; }
এরিক

6
যদিও [1,-1][+!!reverse]সৌন্দর্য ঠান্ডা, এটি একটি ভয়ঙ্কর জিনিস করে আছে। যদি কোনও ব্যবহারকারী আপনার পদ্ধতিটি যথাযথভাবে কল করতে না পারেন, তাকে শাস্তি দিন, কোনওভাবেই তা বোঝার চেষ্টা করবেন না, যাই হোক না কেন।
ইনগো বার্ক

2
উত্স ডেটা প্রস্তুত করা ভাল না, স্পষ্টত উত্স ডেটা কিছু টুইট করার প্রয়োজন হয় যখন এটি ক্রমাগত বিশ্লেষণ কারণ হতে পারে।
জেরিট ব্রিংক

134

এটিকে সাজানোর জন্য আপনাকে দুটি যুক্তি নিয়ে একটি তুলনামূলক ফাংশন তৈরি করতে হবে। তারপরে নিম্নরূপে তুলনামূলক ফাংশনটির সাথে বাছাই করুন ফাংশন:

// a and b are object elements of your array
function mycomparator(a,b) {
  return parseInt(a.price, 10) - parseInt(b.price, 10);
}
homes.sort(mycomparator);

আপনি যদি আরোহণের সাইন করতে চান তবে বিয়োগ চিহ্নের প্রতিটি পাশের অভিব্যক্তিটি পরিবর্তন করুন।


3
এবং এখানে এমন একটি রেফারেন্স দেওয়া হয়েছে যা "এটি খুব জটিল, আপনি যেভাবেই বুঝতে পারবেন না" বলার পরিবর্তে বিষয়টি ব্যাখ্যা করে: ডেভেলপার.মোজিলা.আর.ইন.ইউএস
ডকস / ওয়েব / জাভা স্ক্রিপ্ট /

51

স্ট্রিং বাছাইয়ের ক্ষেত্রে কারও কারও এটির প্রয়োজন হয়,

const dataArr = {

  "hello": [{
    "id": 114,
    "keyword": "zzzzzz",
    "region": "Sri Lanka",
    "supportGroup": "administrators",
    "category": "Category2"
  }, {
    "id": 115,
    "keyword": "aaaaa",
    "region": "Japan",
    "supportGroup": "developers",
    "category": "Category2"
  }]

};
const sortArray = dataArr['hello'];

console.log(sortArray.sort((a, b) => {
  if (a.region < b.region)
    return -1;
  if (a.region > b.region)
    return 1;
  return 0;
}));


38

আপনার যদি কোনও ES6 অনুগত ব্রাউজার থাকে তবে আপনি এটি ব্যবহার করতে পারেন:

আরোহণ এবং সাজানো সাজানোর ক্রমের মধ্যে পার্থক্য হ'ল আপনার তুলনা ফাংশন দ্বারা ফেরত মানের চিহ্ন sign

var ascending = homes.sort((a, b) => Number(a.price) - Number(b.price));
var descending = homes.sort((a, b) => Number(b.price) - Number(a.price));

এখানে একটি কার্যকারী কোড স্নিপেট রয়েছে:

var homes = [{
  "h_id": "3",
  "city": "Dallas",
  "state": "TX",
  "zip": "75201",
  "price": "162500"
}, {
  "h_id": "4",
  "city": "Bevery Hills",
  "state": "CA",
  "zip": "90210",
  "price": "319250"
}, {
  "h_id": "5",
  "city": "New York",
  "state": "NY",
  "zip": "00010",
  "price": "962500"
}];

homes.sort((a, b) => Number(a.price) - Number(b.price));
console.log("ascending", homes);

homes.sort((a, b) => Number(b.price) - Number(a.price));
console.log("descending", homes);


22

আপনি এটি জাভাস্ক্রিপ্টে বাছাই করতে চান, তাই না? আপনি যা চান তা হ'ল sort()ফাংশন । এই ক্ষেত্রে আপনাকে একটি তুলনামূলক ফাংশন লিখতে হবে এবং এটিকে পাস করতে হবে sort(), সুতরাং এরকম কিছু:

function comparator(a, b) {
    return parseInt(a["price"], 10) - parseInt(b["price"], 10);
}

var json = { "homes": [ /* your previous data */ ] };
console.log(json["homes"].sort(comparator));

আপনার তুলনাকারী অ্যারের অভ্যন্তরে প্রতিটি নেস্টেড হ্যাশগুলির একটি গ্রহণ করে এবং "দাম" ক্ষেত্রটি পরীক্ষা করে কোনটি উচ্চতর তা স্থির করে।


21

আমি গিটহাবের প্রস্তাব দিচ্ছি : অ্যারে সারণি বাই - শোয়ার্টজিয়ান ট্রান্সফর্মsortBy ব্যবহার করে এমন পদ্ধতির একটি সর্বোত্তম বাস্তবায়ন

তবে আপাতত আমরা এই পদ্ধতির চেষ্টা করতে যাচ্ছি জিস্ট: সাজ্টবাই-ওল্ড.জেএস
আসুন কিছু সম্পত্তি দ্বারা জিনিস সাজানোর জন্য সক্ষম অ্যারে সাজানোর জন্য একটি পদ্ধতি তৈরি করুন।

বাছাইয়ের ফাংশন তৈরি করা হচ্ছে

var sortBy = (function () {
  var toString = Object.prototype.toString,
      // default parser function
      parse = function (x) { return x; },
      // gets the item to be sorted
      getItem = function (x) {
        var isObject = x != null && typeof x === "object";
        var isProp = isObject && this.prop in x;
        return this.parser(isProp ? x[this.prop] : x);
      };

  /**
   * Sorts an array of elements.
   *
   * @param  {Array} array: the collection to sort
   * @param  {Object} cfg: the configuration options
   * @property {String}   cfg.prop: property name (if it is an Array of objects)
   * @property {Boolean}  cfg.desc: determines whether the sort is descending
   * @property {Function} cfg.parser: function to parse the items to expected type
   * @return {Array}
   */
  return function sortby (array, cfg) {
    if (!(array instanceof Array && array.length)) return [];
    if (toString.call(cfg) !== "[object Object]") cfg = {};
    if (typeof cfg.parser !== "function") cfg.parser = parse;
    cfg.desc = !!cfg.desc ? -1 : 1;
    return array.sort(function (a, b) {
      a = getItem.call(cfg, a);
      b = getItem.call(cfg, b);
      return cfg.desc * (a < b ? -1 : +(a > b));
    });
  };

}());

অচলিত ডেটা সেট করা হচ্ছে

var data = [
  {date: "2011-11-14T16:30:43Z", quantity: 2, total: 90,  tip: 0,   type: "tab"},
  {date: "2011-11-14T17:22:59Z", quantity: 2, total: 90,  tip: 0,   type: "Tab"},
  {date: "2011-11-14T16:28:54Z", quantity: 1, total: 300, tip: 200, type: "visa"},
  {date: "2011-11-14T16:53:41Z", quantity: 2, total: 90,  tip: 0,   type: "tab"},
  {date: "2011-11-14T16:48:46Z", quantity: 2, total: 90,  tip: 0,   type: "tab"},
  {date: "2011-11-14T17:25:45Z", quantity: 2, total: 200, tip: 0,   type: "cash"},
  {date: "2011-11-31T17:29:52Z", quantity: 1, total: 200, tip: 100, type: "Visa"},
  {date: "2011-11-14T16:58:03Z", quantity: 2, total: 90,  tip: 0,   type: "tab"},
  {date: "2011-11-14T16:20:19Z", quantity: 2, total: 190, tip: 100, type: "tab"},
  {date: "2011-11-01T16:17:54Z", quantity: 2, total: 190, tip: 100, type: "tab"},
  {date: "2011-11-14T17:07:21Z", quantity: 2, total: 90,  tip: 0,   type: "tab"},
  {date: "2011-11-14T16:54:06Z", quantity: 1, total: 100, tip: 0,   type: "Cash"}
];

এটি ব্যবহার করছি

"date"হিসাবে অ্যারে সাজানString

// sort by @date (ascending)
sortBy(data, { prop: "date" });

// expected: first element
// { date: "2011-11-01T16:17:54Z", quantity: 2, total: 190, tip: 100, type: "tab" }

// expected: last element
// { date: "2011-11-31T17:29:52Z", quantity: 1, total: 200, tip: 100, type: "Visa"}

আপনি যদি সংবেদনশীল parserকেসটিকে উপেক্ষা করতে চান, কলব্যাক সেট করুন :

// sort by @type (ascending) IGNORING case-sensitive
sortBy(data, {
    prop: "type",
    parser: (t) => t.toUpperCase()
});

// expected: first element
// { date: "2011-11-14T16:54:06Z", quantity: 1, total: 100, tip: 0, type: "Cash" }

// expected: last element
// { date: "2011-11-31T17:29:52Z", quantity: 1, total: 200, tip: 100, type: "Visa" }

আপনি যদি "date"ক্ষেত্রটি Dateটাইপ হিসাবে রূপান্তর করতে চান :

// sort by @date (descending) AS Date object
sortBy(data, {
    prop: "date",
    desc: true,
    parser: (d) => new Date(d)
});

// expected: first element
// { date: "2011-11-31T17:29:52Z", quantity: 1, total: 200, tip: 100, type: "Visa"}

// expected: last element
// { date: "2011-11-01T16:17:54Z", quantity: 2, total: 190, tip: 100, type: "tab" }

এখানে আপনি কোডটি খেলতে পারেন: jsbin.com/lesebi

@ ওজেশকে তার প্রতিক্রিয়া জানিয়ে ধন্যবাদ , মিথ্যা মানগুলির সাথে সম্পত্তি সম্পর্কিত সমস্যাটি স্থির হয়েছিল।


ক্ষেত্রটি শূন্য হলে এটি বিরতি বলে মনে হচ্ছে।
টিএসএনভ

আপনি যদি সংখ্যাগুলির মাধ্যমে বাছাই করেন এবং আপনি যদি বস্তুর অ্যারেগুলির মধ্যে একটি '0' এর মুখোমুখি হন তবে আপনি লক্ষ্য করতে পারেন যে উপরের কোডটি বিরতি পেয়েছে Hereএর জন্য এখানে একটি দ্রুত ফিক্স রয়েছে: var checkNaN = function (value) { return Number.isNaN(Number(value)) ? 0 : value; } তারপরে: রিটার্ন ফাংশন (অ্যারে, ও) { .... a = _getItem.call (ও, ক); a = checkNaN (a); b = _getItem.call (ও, খ); b = checkNaN (খ); রিটার্ন o.desc * (a <b? -1: + (a> b)); });
ওজেশ

18

লড্যাশ.সোর্টবি দ্বারা , ( কমনজ ব্যবহারের নির্দেশাবলী, আপনি কেবলমাত্র এইচটিএমএলের শীর্ষে সিডিএন -র জন্য স্ক্রিপ্টটি অন্তর্ভুক্ত করতে পারেন )

var sortBy = require('lodash.sortby');
// or
sortBy = require('lodash').sortBy;

অবতরণ ক্রম

var descendingOrder = sortBy( homes, 'price' ).reverse();

উর্দ্ধক্রমানুসারে

var ascendingOrder = sortBy( homes, 'price' );

1
বাconst sortBy = require('lodash/sortBy'); let calendars = sortBy(calendarListResponse.items, cal => cal.summary);
এমপেন

নিশ্চিত নয় যে লোড্যাশটি সম্প্রতি নামকরণ করা অর্ডারবাইয়ের মাধ্যমে পরিবর্তিত হয়েছেimport { orderBy } from 'lodash'; ... ... return orderBy ( rows, 'fieldName' ).reverse();
মন্টেলোফ

8

এটি একটি সাধারণ এক লাইনের মান () সাজানোর ক্রিয়াকলাপের মাধ্যমে অর্জন করা যেতে পারে । ডেমো দেখতে নীচে কোড স্নিপেট চালান।

var homes = [
    {
        "h_id": "3",
        "city": "Dallas",
        "state": "TX",
        "zip": "75201",
        "price": "162500"
    }, {
        "h_id": "4",
        "city": "Bevery Hills",
        "state": "CA",
        "zip": "90210",
        "price": "319250"
    }, {
        "h_id": "5",
        "city": "New York",
        "state": "NY",
        "zip": "00010",
        "price": "962500"
    }
];

console.log("To sort descending/highest first, use operator '<'");

homes.sort(function(a,b) { return a.price.valueOf() < b.price.valueOf();});

console.log(homes);

console.log("To sort ascending/lowest first, use operator '>'");

homes.sort(function(a,b) { return a.price.valueOf() > b.price.valueOf();});

console.log(homes);


8

আমি পার্টির জন্য একটু দেরি করছি তবে বাছাইয়ের জন্য আমার যুক্তিটি নীচে রয়েছে।

function getSortedData(data, prop, isAsc) {
    return data.sort((a, b) => {
        return (a[prop] < b[prop] ? -1 : 1) * (isAsc ? 1 : -1)
    });
}

6

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

  • AZ বর্ণমালা অনুসারে বাছাই করুন
  • একই শব্দের বড় হাতের মানগুলি ছোট হাতের মানগুলির আগে আসা উচিত
  • একই অক্ষর (এ / এ, বি / বি) মানগুলি একসাথে ভাগ করা উচিত

আমি যা আশা করি তা হ'ল [ A, a, B, b, C, c ]উপরের উত্তরগুলি A, B, C, a, b, c। আমি আসলে আমার চেয়ে বেশি দিন এটির জন্য আমার মাথা আঁচড়ান (যে কারণে আমি এটি পোস্ট করে দিচ্ছি যে এটি কমপক্ষে একজন অন্য ব্যক্তিকে সহায়তা করবে) এই আশায়। দুটি ব্যবহারকারী localeCompareচিহ্নিত উত্তরের জন্য মন্তব্যে ফাংশনটি উল্লেখ করার সময়, চারপাশে অনুসন্ধান করার সময় আমি ফাংশনটিতে হোঁচট খাওয়ার পরেও আমি দেখতে পেলাম না। String.prototype.localeCompare () ডকুমেন্টেশন পড়ার পরে আমি এটি নিয়ে আসতে সক্ষম হয়েছি:

var values = [ "Delta", "charlie", "delta", "Charlie", "Bravo", "alpha", "Alpha", "bravo" ];
var sorted = values.sort((a, b) => a.localeCompare(b, undefined, { caseFirst: "upper" }));
// Result: [ "Alpha", "alpha", "Bravo", "bravo", "Charlie", "charlie", "Delta", "delta" ]

এটি ছোট হাতের মানগুলির আগে বড় হাতের মানকে বাছাই করতে ফাংশনটিকে বলে। localeCompareফাংশনটির দ্বিতীয় প্যারামিটারটি হ'ল লোকালটি সংজ্ঞায়িত করা হয় তবে আপনি যদি এটি ছেড়ে দেন তবে undefinedএটি আপনার জন্য স্বয়ংক্রিয়ভাবে লোকালটি বের করে।

এটি অবজেক্টগুলির অ্যারে বাছাই করার জন্য একই কাজ করে:

var values = [
    { id: 6, title: "Delta" },
    { id: 2, title: "charlie" },
    { id: 3, title: "delta" },
    { id: 1, title: "Charlie" },
    { id: 8, title: "Bravo" },
    { id: 5, title: "alpha" },
    { id: 4, title: "Alpha" },
    { id: 7, title: "bravo" }
];
var sorted = values
    .sort((a, b) => a.title.localeCompare(b.title, undefined, { caseFirst: "upper" }));

5

আপনি sortকলব্যাক ফাংশন সহ জাভাস্ক্রিপ্ট পদ্ধতিটি ব্যবহার করতে পারেন :

function compareASC(homeA, homeB)
{
    return parseFloat(homeA.price) - parseFloat(homeB.price);
}

function compareDESC(homeA, homeB)
{
    return parseFloat(homeB.price) - parseFloat(homeA.price);
}

// Sort ASC
homes.sort(compareASC);

// Sort DESC
homes.sort(compareDESC);

4

এখানে উপরের সমস্ত উত্তরের একটি সমাপ্তি।

ফিডলের বৈধতা: http://jsfiddle.net/bobberino/4qqk3/

var sortOn = function (arr, prop, reverse, numeric) {

    // Ensure there's a property
    if (!prop || !arr) {
        return arr
    }

    // Set up sort function
    var sort_by = function (field, rev, primer) {

        // Return the required a,b function
        return function (a, b) {

            // Reset a, b to the field
            a = primer(a[field]), b = primer(b[field]);

            // Do actual sorting, reverse as needed
            return ((a < b) ? -1 : ((a > b) ? 1 : 0)) * (rev ? -1 : 1);
        }

    }

    // Distinguish between numeric and string to prevent 100's from coming before smaller
    // e.g.
    // 1
    // 20
    // 3
    // 4000
    // 50

    if (numeric) {

        // Do sort "in place" with sort_by function
        arr.sort(sort_by(prop, reverse, function (a) {

            // - Force value to a string.
            // - Replace any non numeric characters.
            // - Parse as float to allow 0.02 values.
            return parseFloat(String(a).replace(/[^0-9.-]+/g, ''));

        }));
    } else {

        // Do sort "in place" with sort_by function
        arr.sort(sort_by(prop, reverse, function (a) {

            // - Force value to string.
            return String(a).toUpperCase();

        }));
    }


}

আপনি কি দয়া করে ব্যাখ্যা করতে পারবেন * (রেভ? -1: 1) থাকার তাত্পর্য কি;
টেকটার্টল

এটি ক্রমটিকে বিপরীত করতে হবে (ক্রম বর্ধমান বনাম আরোহণ) যখন রেভ যুক্তিটি সত্য হয় তখন রেভ অংশটি কেবলমাত্র সাধারণ ফলাফলগুলি ফ্লিপ করে। অন্যথায় এটি কেবল 1 দ্বারা একাধিক হবে যা কখনই কিছুই করে না, সেট করার পরে এটি ফলাফলকে -1 দিয়ে গুণ করবে, ফলস্বরূপ ফলাফলটি উল্টে দেবে।
বব

3

আমি এক ধরণের রেটিং এবং একাধিক ক্ষেত্র বাছাইয়ের সাথেও কাজ করেছি:

arr = [
    {type:'C', note:834},
    {type:'D', note:732},
    {type:'D', note:008},
    {type:'F', note:474},
    {type:'P', note:283},
    {type:'P', note:165},
    {type:'X', note:173},
    {type:'Z', note:239},
];

arr.sort(function(a,b){        
    var _a = ((a.type==='C')?'0':(a.type==='P')?'1':'2');
    _a += (a.type.localeCompare(b.type)===-1)?'0':'1';
    _a += (a.note>b.note)?'1':'0';
    var _b = ((b.type==='C')?'0':(b.type==='P')?'1':'2');
    _b += (b.type.localeCompare(a.type)===-1)?'0':'1';
    _b += (b.note>a.note)?'1':'0';
    return parseInt(_a) - parseInt(_b);
});

ফলাফল

[
    {"type":"C","note":834},
    {"type":"P","note":165},
    {"type":"P","note":283},
    {"type":"D","note":8},
    {"type":"D","note":732},
    {"type":"F","note":474},
    {"type":"X","note":173},
    {"type":"Z","note":239}
]

3

এটি কেবলমাত্র একটি একক অ্যারে বাছাই করার জন্য ওভারকিলের সামান্য হলেও, এই প্রোটোটাইপ ফাংশন জাভাস্ক্রিপ্ট অ্যারেগুলিকে যেকোন কী দ্বারা সাজানো বা নেমে যাওয়া ক্রমে, নেস্টেড কীগুলি সহ , dotসিনট্যাক্স ব্যবহার করে বাছাই করতে দেয়।

(function(){
    var keyPaths = [];

    var saveKeyPath = function(path) {
        keyPaths.push({
            sign: (path[0] === '+' || path[0] === '-')? parseInt(path.shift()+1) : 1,
            path: path
        });
    };

    var valueOf = function(object, path) {
        var ptr = object;
        for (var i=0,l=path.length; i<l; i++) ptr = ptr[path[i]];
        return ptr;
    };

    var comparer = function(a, b) {
        for (var i = 0, l = keyPaths.length; i < l; i++) {
            aVal = valueOf(a, keyPaths[i].path);
            bVal = valueOf(b, keyPaths[i].path);
            if (aVal > bVal) return keyPaths[i].sign;
            if (aVal < bVal) return -keyPaths[i].sign;
        }
        return 0;
    };

    Array.prototype.sortBy = function() {
        keyPaths = [];
        for (var i=0,l=arguments.length; i<l; i++) {
            switch (typeof(arguments[i])) {
                case "object": saveKeyPath(arguments[i]); break;
                case "string": saveKeyPath(arguments[i].match(/[+-]|[^.]+/g)); break;
            }
        }
        return this.sort(comparer);
    };    
})();

ব্যবহার:

var data = [
    { name: { first: 'Josh', last: 'Jones' }, age: 30 },
    { name: { first: 'Carlos', last: 'Jacques' }, age: 19 },
    { name: { first: 'Carlos', last: 'Dante' }, age: 23 },
    { name: { first: 'Tim', last: 'Marley' }, age: 9 },
    { name: { first: 'Courtney', last: 'Smith' }, age: 27 },
    { name: { first: 'Bob', last: 'Smith' }, age: 30 }
]

data.sortBy('age'); // "Tim Marley(9)", "Carlos Jacques(19)", "Carlos Dante(23)", "Courtney Smith(27)", "Josh Jones(30)", "Bob Smith(30)"

বিন্দু-সিনট্যাক্স বা অ্যারে-সিনট্যাক্স সহ নেস্টেড বৈশিষ্ট্য অনুসারে বাছাই করা:

data.sortBy('name.first'); // "Bob Smith(30)", "Carlos Dante(23)", "Carlos Jacques(19)", "Courtney Smith(27)", "Josh Jones(30)", "Tim Marley(9)"
data.sortBy(['name', 'first']); // "Bob Smith(30)", "Carlos Dante(23)", "Carlos Jacques(19)", "Courtney Smith(27)", "Josh Jones(30)", "Tim Marley(9)"

একাধিক কী অনুসারে বাছাই করা হচ্ছে:

data.sortBy('name.first', 'age'); // "Bob Smith(30)", "Carlos Jacques(19)", "Carlos Dante(23)", "Courtney Smith(27)", "Josh Jones(30)", "Tim Marley(9)"
data.sortBy('name.first', '-age'); // "Bob Smith(30)", "Carlos Dante(23)", "Carlos Jacques(19)", "Courtney Smith(27)", "Josh Jones(30)", "Tim Marley(9)"

আপনি রেপো কাঁটাচামচ করতে পারেন: https://github.com/eneko/Array.sortBy


sortByসংক্ষিপ্ত বাক্য গঠনের কারণে আমি এই উত্তরটি অনেক পছন্দ করি । দুর্দান্ত কোড-পঠনযোগ্যতা বজায় রাখার সময় নেস্টেড ফিল্ডগুলির সাথে ব্যবহার করা সহজ। ধন্যবাদ!
ম্যানফ্রেড আরবান

3

ইসমাস্ক্রিপ্ট With সহ স্টোবরের উত্তরটি আরও সংক্ষিপ্তভাবে করা যেতে পারে:

homes.sort((a, b) => a.price - b.price)

3

দামের উতরাইয়ের ক্রম:

homes.sort((x,y) => {return y.price - x.price})

দামের আরোহী ক্রম:

homes.sort((x,y) => {return x.price - y.price})

2

একটি অ্যারে বাছাই করার জন্য আপনাকে অবশ্যই তুলনাকারী কার্যটি সংজ্ঞায়িত করতে হবে। এই ফাংশনটি সর্বদা আপনার পছন্দসই বাছাই করার ধরণ বা ক্রম (যেমন আরোহী বা অবতরণ) -এর চেয়ে আলাদা।

আসুন এমন কিছু ফাংশন তৈরি করুন যা একটি অ্যারেটিকে আরোহণ বা উতরাইয়ের সাজান এবং এতে অবজেক্ট বা স্ট্রিং বা সংখ্যাসম্য থাকে।

function sorterAscending(a,b) {
    return a-b;
}

function sorterDescending(a,b) {
    return b-a;
}

function sorterPriceAsc(a,b) {
    return parseInt(a['price']) - parseInt(b['price']);
}

function sorterPriceDes(a,b) {
    return parseInt(b['price']) - parseInt(b['price']);
}

নম্বরগুলি বাছাই করুন (বর্ণানুক্রমিক এবং আরোহী):

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.sort();

নম্বরগুলি বাছাই করুন (বর্ণানুক্রমিক এবং উতরাই):

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.sort();
fruits.reverse();

নম্বরগুলি বাছাই করুন (সংখ্যাসূচক এবং আরোহী):

var points = [40,100,1,5,25,10];
points.sort(sorterAscending());

নম্বরগুলি বাছাই করুন (সংখ্যাসূচক এবং অবতরণীয়):

var points = [40,100,1,5,25,10];
points.sort(sorterDescending());

উপরের হিসাবে পছন্দসই কী সহ আপনার অ্যারের সাথে सॉર્টারপ্রেসএএসসি এবং সর্টারপ্রেসডেস পদ্ধতিটি ব্যবহার করুন।

homes.sort(sorterPriceAsc()) or homes.sort(sorterPriceDes())


2

"জাভাস্ক্রিপ্ট: দ্য গুড পার্টস" বইটি থেকে মার্জিত বাস্তবায়নের কিছুটা পরিবর্তিত সংস্করণ এখানে।

উল্লেখ্য : এই সংস্করণটি byহল স্থিতিশীল । এটি পরবর্তী শৃঙ্খলিত বাছাই করার সময় প্রথম ক্রমের ক্রম সংরক্ষণ করে।

আমি isAscendingএটিতে পরামিতি যুক্ত করেছি। এটিকে ES6মানক এবং "নতুন" ভাল অংশগুলিতে লেখকের সুপারিশ অনুসারে রূপান্তরিত করুন ।

আপনি একাধিক বৈশিষ্ট্য অনুসারে আরোহণের পাশাপাশি উতরাই এবং শৃঙ্খলা বাছাই করতে পারেন।

const by = function (name, minor, isAscending=true) {
    const reverseMutliplier = isAscending ? 1 : -1;
    return function (o, p) {
        let a, b;
        let result;
        if (o && p && typeof o === "object" && typeof p === "object") {
            a = o[name];
            b = p[name];
            if (a === b) {
                return typeof minor === 'function' ? minor(o, p) : 0;
            }
            if (typeof a === typeof b) {
                result = a < b ? -1 : 1;
            } else {
                result = typeof a < typeof b ? -1 : 1;
            }
            return result * reverseMutliplier;
        } else {
            throw {
                name: "Error",
                message: "Expected an object when sorting by " + name
            };
        }
    };
};

let s = [
    {first: 'Joe',   last: 'Besser'},
    {first: 'Moe',   last: 'Howard'},
    {first: 'Joe',   last: 'DeRita'},
    {first: 'Shemp', last: 'Howard'},
    {first: 'Larry', last: 'Fine'},
    {first: 'Curly', last: 'Howard'}
];

// Sort by: first ascending, last ascending
s.sort(by("first", by("last")));    
console.log("Sort by: first ascending, last ascending: ", s);     // "[
//     {"first":"Curly","last":"Howard"},
//     {"first":"Joe","last":"Besser"},     <======
//     {"first":"Joe","last":"DeRita"},     <======
//     {"first":"Larry","last":"Fine"},
//     {"first":"Moe","last":"Howard"},
//     {"first":"Shemp","last":"Howard"}
// ]

// Sort by: first ascending, last descending
s.sort(by("first", by("last", 0, false)));  
console.log("sort by: first ascending, last descending: ", s);    // "[
//     {"first":"Curly","last":"Howard"},
//     {"first":"Joe","last":"DeRita"},     <========
//     {"first":"Joe","last":"Besser"},     <========
//     {"first":"Larry","last":"Fine"},
//     {"first":"Moe","last":"Howard"},
//     {"first":"Shemp","last":"Howard"}
// ]


আমরা {"first":"Curly","last":"Howard", "property" : {"id" : "1"}}আইডি দ্বারা অ্যারের ধরণের বাছাই করতে পারে ?
বিশাল কুমার সাহু

হ্যাঁ, একটি নতুন প্যারামিটার নিতে ফাংশনটি কিছুটা পরিবর্তন করতে হবে, বলুন, নেস্টেডনাম। তারপরে আপনি byনাম = "সম্পত্তি", নেস্টেড নেম = "আইডি" দিয়ে কল করুন
পৌরাণিক

2

উপাদানের সাধারণ অ্যারের মানগুলির জন্য:

function sortArrayOfElements(arrayToSort) {
    function compareElements(a, b) {
        if (a < b)
            return -1;
        if (a > b)
            return 1;
        return 0;
    }

    return arrayToSort.sort(compareElements);
}

e.g. 1:
var array1 = [1,2,545,676,64,2,24]
output : [1, 2, 2, 24, 64, 545, 676]

var array2 = ["v","a",545,676,64,2,"24"]
output: ["a", "v", 2, "24", 64, 545, 676]

বস্তুর অ্যারের জন্য:

function sortArrayOfObjects(arrayToSort, key) {
    function compareObjects(a, b) {
        if (a[key] < b[key])
            return -1;
        if (a[key] > b[key])
            return 1;
        return 0;
    }

    return arrayToSort.sort(compareObjects);
}

e.g. 1: var array1= [{"name": "User4", "value": 4},{"name": "User3", "value": 3},{"name": "User2", "value": 2}]

output : [{"name": "User2", "value": 2},{"name": "User3", "value": 3},{"name": "User4", "value": 4}]

2

নীচের কোডটি ব্যবহার করে ইনপুটটির ভিত্তিতে একটি ফাংশন তৈরি করুন এবং সাজান

var homes = [{

    "h_id": "3",
    "city": "Dallas",
    "state": "TX",
    "zip": "75201",
    "price": "162500"

 }, {

    "h_id": "4",
    "city": "Bevery Hills",
    "state": "CA",
    "zip": "90210",
    "price": "319250"

 }, {

    "h_id": "5",
    "city": "New York",
    "state": "NY",
    "zip": "00010",
    "price": "962500"

 }];

 function sortList(list,order){
     if(order=="ASC"){
        return list.sort((a,b)=>{
            return parseFloat(a.price) - parseFloat(b.price);
        })
     }
     else{
        return list.sort((a,b)=>{
            return parseFloat(b.price) - parseFloat(a.price);
        });
     }
 }

 sortList(homes,'DESC');
 console.log(homes);

2

স্ট্রিং তুলনার জন্য আপনি স্ট্রিং 1.localeCompare (স্ট্রিং 2) ব্যবহার করতে পারেন

this.myArray.sort((a,b) => { 
    return a.stringProp.localeCompare(b.stringProp);
});

লক্ষ্য করুন localCompareক্ষেত্রে দেখা যায় এর মধ্যে সংবেদনশীল


1

একাধিক অ্যারে অবজেক্ট ক্ষেত্রে সাজানোর জন্য। আপনার ক্ষেত্রের নামটি arrpropঅ্যারেতে প্রবেশ করুন ["a","b","c"] তারপরে দ্বিতীয় প্যারামিটারের arrsourceআসল উত্সে পাস করুন যা আমরা সাজানোর জন্য চাই।

function SortArrayobject(arrprop,arrsource){
arrprop.forEach(function(i){
arrsource.sort(function(a,b){
return ((a[i] < b[i]) ? -1 : ((a[i] > b[i]) ? 1 : 0));
});
});
return arrsource;
}

1

আপনার দুটি ফাংশন প্রয়োজন হবে

function desc(a, b) {
 return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
}

function asc(a, b) {
  return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
}

তারপরে আপনি এটিকে যে কোনও বস্তুর সম্পত্তিতে প্রয়োগ করতে পারেন:

 data.sort((a, b) => desc(parseFloat(a.price), parseFloat(b.price)));

let data = [
    {label: "one", value:10},
    {label: "two", value:5},
    {label: "three", value:1},
];

// sort functions
function desc(a, b) {
 return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
}

function asc(a, b) {
 return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
}

// DESC
data.sort((a, b) => desc(a.value, b.value));

document.body.insertAdjacentHTML(
 'beforeend', 
 '<strong>DESCending sorted</strong><pre>' + JSON.stringify(data) +'</pre>'
);

// ASC
data.sort((a, b) => asc(a.value, b.value));

document.body.insertAdjacentHTML(
 'beforeend', 
 '<strong>ASCending sorted</strong><pre>' + JSON.stringify(data) +'</pre>'
);


0

আপনি যদি এটি ব্যবহার করতে চান তবে আপনার জন্য এটি পরিচালনা করার জন্য আমি সম্প্রতি একটি সর্বজনীন ফাংশন লিখেছি।

/**
 * Sorts an object into an order
 *
 * @require jQuery
 *
 * @param object Our JSON object to sort
 * @param type Only alphabetical at the moment
 * @param identifier The array or object key to sort by
 * @param order Ascending or Descending
 *
 * @returns Array
 */
function sortItems(object, type, identifier, order){

    var returnedArray = [];
    var emptiesArray = []; // An array for all of our empty cans

    // Convert the given object to an array
    $.each(object, function(key, object){

        // Store all of our empty cans in their own array
        // Store all other objects in our returned array
        object[identifier] == null ? emptiesArray.push(object) : returnedArray.push(object);

    });

    // Sort the array based on the type given
    switch(type){

        case 'alphabetical':

            returnedArray.sort(function(a, b){

                return(a[identifier] == b[identifier]) ? 0 : (

                    // Sort ascending or descending based on order given
                    order == 'asc' ? a[identifier] > b[identifier] : a[identifier] < b[identifier]

                ) ? 1 : -1;

            });

            break;

        default:

    }

    // Return our sorted array along with the empties at the bottom depending on sort order
    return order == 'asc' ? returnedArray.concat(emptiesArray) : emptiesArray.concat(returnedArray);

}

0
homes.sort(function(a, b){
  var nameA=a.prices.toLowerCase(), nameB=b.prices.toLowerCase()
  if (nameA < nameB) //sort string ascending
    return -1 
  if (nameA > nameB)
    return 1
  return 0 //default return value (no sorting)
})

0

এই নিবন্ধটি পড়ার পরে হাই, আমি একাধিক জসন বৈশিষ্ট্যের তুলনায় কার্যকারিতা সহ আমার প্রয়োজনগুলির জন্য একটি প্রকারের তৈরি করেছি, এবং আমি এটি আপনার সাথে ভাগ করতে চাই।

এই সমাধানটি কেবল আরোহী ক্রমের সাথে স্ট্রিংগুলির তুলনা করে তবে সমাধানটি প্রতিটি বৈশিষ্ট্যের পক্ষে সমর্থন করার পক্ষে সহজতর করা যেতে পারে: বিপরীত ক্রম, অন্য ডেটা ধরণের, লোকেল ব্যবহার, কাস্টিং ইত্যাদি support

var homes = [{

    "h_id": "3",
    "city": "Dallas",
    "state": "TX",
    "zip": "75201",
    "price": "162500"

}, {

    "h_id": "4",
    "city": "Bevery Hills",
    "state": "CA",
    "zip": "90210",
    "price": "319250"

}, {

    "h_id": "5",
    "city": "New York",
    "state": "NY",
    "zip": "00010",
    "price": "962500"

}];

// comp = array of attributes to sort
// comp = ['attr1', 'attr2', 'attr3', ...]
function sortComparator(a, b, comp) {
    // Compare the values of the first attribute
    if (a[comp[0]] === b[comp[0]]) {
        // if EQ proceed with the next attributes
        if (comp.length > 1) {
            return sortComparator(a, b, comp.slice(1));
        } else {
            // if no more attributes then return EQ
            return 0;
        }
    } else {
        // return less or great
        return (a[comp[0]] < b[comp[0]] ? -1 : 1)
    }
}

// Sort array homes
homes.sort(function(a, b) {
    return sortComparator(a, b, ['state', 'city', 'zip']);
});

// display the array
homes.forEach(function(home) {
    console.log(home.h_id, home.city, home.state, home.zip, home.price);
});

এবং ফলাফল হয়

$ node sort
4 Bevery Hills CA 90210 319250
5 New York NY 00010 962500
3 Dallas TX 75201 162500

এবং অন্য ধরণের

homes.sort(function(a, b) {
    return sortComparator(a, b, ['city', 'zip']);
});

ফলস্বরূপ

$ node sort
4 Bevery Hills CA 90210 319250
3 Dallas TX 75201 162500
5 New York NY 00010 962500

0

একটি সাধারণ কোড:

    var homes = [
        {
            "h_id": "3",
            "city": "Dallas",
            "state": "TX",
            "zip": "75201",
            "price": "162500"
        }, {
            "h_id": "4",
            "city": "Bevery Hills",
            "state": "CA",
            "zip": "90210",
            "price": "319250"
        }, {
            "h_id": "5",
            "city": "New York",
            "state": "NY",
            "zip": "00010",
            "price": "962500"
        }
    ];

    let sortByPrice = homes.sort(function (a, b) 
    {
      return parseFloat(b.price) - parseFloat(a.price);
    });

    for (var i=0; i<sortByPrice.length; i++)
    {
      document.write(sortByPrice[i].h_id+' '+sortByPrice[i].city+' '
       +sortByPrice[i].state+' '
       +sortByPrice[i].zip+' '+sortByPrice[i].price);
      document.write("<br>");
    }


0
 function compareValues(key, order = 'asc') {
  return function innerSort(a, b) {
    if (!a.hasOwnProperty(key) || !b.hasOwnProperty(key)) {
      // property doesn't exist on either object
      return 0;
    }

    const varA = (typeof a[key] === 'string')
      ? a[key].toUpperCase() : a[key];
    const varB = (typeof b[key] === 'string')
      ? b[key].toUpperCase() : b[key];

    let comparison = 0;
    if (varA > varB) {
      comparison = 1;
    } else if (varA < varB) {
      comparison = -1;
    }
    return (
      (order === 'desc') ? (comparison * -1) : comparison
    );
  };
}

http://yazilimsozluk.com/sort-array-in-javascript-by-asc-or-desc

আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.