संपत्ति मूल्यों द्वारा वस्तुओं की एक सरणी को छाँटना

Question

मुझे AJAX का उपयोग करते हुए निम्नलिखित वस्तुएं मिली हैं और उन्हें एक सरणी में संग्रहीत किया है:

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में संपत्ति द्वारा वस्तुओं को सॉर्ट करने के लिए एक फ़ंक्शन कैसे बना सकता हूं ?

Comments

सबसे तेज़ तरीका आइसोमॉर्फिक सॉर्ट-एरे- मॉड्यूल का उपयोग करना है जो किसी भी प्रकार के इनपुट, कंप्यूटेड फ़ील्ड और कस्टम सॉर्ट ऑर्डर का समर्थन करते हुए ब्राउज़र और नोड दोनों में मूल रूप से काम करता है।

— लॉयड

Answer 1

बढ़ते क्रम में मूल्य के आधार पर घरों को छाँटें:

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

या ES6 संस्करण के बाद:

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

कुछ दस्तावेज यहां देखे जा सकते हैं ।

Comments

आप string1.localeCompare(string2)स्ट्रिंग तुलना के लिए उपयोग कर सकते हैं

— ब्रैडवीडो

ध्यान रखें कि localeCompare()मामला असंवेदनशील है । यदि आप केस संवेदनशील चाहते हैं, तो आप उपयोग कर सकते हैं (string1 > string2) - (string1 < string2)। अंतर की गणना करने के लिए बूलियन मानों को पूर्णांक 0 और 1 के लिए मजबूर किया जाता है।

— डॉन किर्कबी

अपडेट के लिए धन्यवाद, @ पॉइंट्टी, मुझे इस समस्या में भागना याद नहीं है, लेकिन शायद पिछले कुछ वर्षों में व्यवहार बदल गया है। भले ही, localeCompare()प्रलेखन से पता चलता है कि आप स्पष्ट रूप से बता सकते हैं कि क्या आप मामले की संवेदनशीलता, संख्यात्मक छंटाई और अन्य विकल्प चाहते हैं।

— डॉन किर्कबी

@ sg28 मुझे लगता है कि आपने MDN स्पष्टीकरण को गलत समझा है। यह नहीं कहता है कि सॉर्ट फ़ंक्शन विश्वसनीय नहीं है , यह कहता है कि यह स्थिर नहीं है । मैं समझता हूं कि यह भ्रमित क्यों हो सकता है, लेकिन यह दावा नहीं है कि यह उपयोग के लिए उपयुक्त नहीं है। एल्गोरिदम को सॉर्ट करने के संदर्भ में, स्थिर शब्द का एक विशिष्ट अर्थ है - सूची में "समान" तत्वों को उसी क्रम में क्रमबद्ध किया जाता है जैसे इनपुट में । यह पूरी तरह से कोड के विचार से असंबंधित है जो अस्थिर है (यानी उपयोग के लिए अभी तक तैयार नहीं है)।

— स्टोबोर

यदि आप शहर के उदाहरण के लिए एक विशिष्ट स्ट्रिंग मानों को क्रमबद्ध करना चाहते हैं, तो आप इसका उपयोग कर सकते हैं: this.homes.sort ((वर्तमान, अगला) => {return current.city.localeCompare (next.city)});

— जॉर्ज वेलवर्ट

Answer 2

यहां एक अधिक लचीला संस्करण है, जो आपको पुन: प्रयोज्य सॉर्ट फ़ंक्शन बनाने और किसी भी क्षेत्र द्वारा सॉर्ट करने की अनुमति देता है।

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

Comments

निकल - आप कोड को गलत बता रहे हैं। sort_byO (1) में चलता है, और एक सूची में आइटम की तुलना करने के लिए अंतर्निहित सॉर्ट (O (N लॉग एन)) द्वारा उपयोग किए गए फ़ंक्शन को देता है। कुल जटिलता ओ (एन लॉग एन) * ओ (1) है जो ओ (एन लॉग एन) को कम करती है, या एक त्वरित प्रकार के समान है।

— त्रिकोणीय

मेरे पास एक मुद्दा यह है कि रिवर्स = गलत के साथ, यह 1,2,3,4 के रूप में संख्याओं को सॉर्ट करेगा ... लेकिन स्ट्रिंग्स के रूप में z, y, x ...

— Abby

एक छोटी वृद्धि:var key = primer ? function (x) { return primer(x[field]); } : function (x) { return x[field]; }

— एरिक

जबकि [1,-1][+!!reverse]अच्छा लग रहा है, यह एक भयानक बात है। यदि कोई उपयोगकर्ता आपकी विधि को ठीक से नहीं कह सकता है, तो उसे दंडित करें, किसी भी तरह से इसका अर्थ निकालने की कोशिश न करें, चाहे जो भी हो।

— इंगो बुर्क

क्या स्रोत डेटा को तैयार करना बेहतर नहीं होगा, यह लगातार पार्सिंग का कारण होगा जब स्पष्ट रूप से स्रोत डेटा को कुछ ट्विकिंग की आवश्यकता होगी।

— गेरिट ब्रिंक

Answer 3

इसे क्रमबद्ध करने के लिए आपको दो तर्क लेते हुए एक तुलनित्र फलन बनाने की आवश्यकता है। फिर उस तुलनित्र फ़ंक्शन के साथ सॉर्ट फ़ंक्शन को निम्नानुसार कॉल करें:

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

यदि आप आरोही क्रमबद्ध करना चाहते हैं तो ऋण चिन्ह के प्रत्येक तरफ के भाव बदल सकते हैं।

Comments

और यहाँ एक संदर्भ है जो वास्तव में "यह बहुत जटिल है, कहने के बजाय विषय की व्याख्या करता है, आप इसे वैसे भी समझ नहीं पाएंगे": developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…

— रॉलैंड इलिग

Answer 4

यदि किसी को इसकी आवश्यकता हो तो स्ट्रिंग की छंटाई के लिए,

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

Answer 5

यदि आपके पास ES6 अनुरूप ब्राउज़र है तो आप इसका उपयोग कर सकते हैं:

• तीर कार्य
• संख्या () फ़ंक्शन
• सॉर्ट () फ़ंक्शन

आरोही और अवरोही क्रम के बीच का अंतर आपके तुलनात्मक कार्य द्वारा लौटाए गए मूल्य का संकेत है:

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

Answer 6

आप इसे जावास्क्रिप्ट में सॉर्ट करना चाहते हैं, है ना? आप जो चाहते हैं वह 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));

आपका तुलनित्र प्रत्येक नेस्टेड हैश में से प्रत्येक को सरणी के अंदर ले जाता है और निर्णय करता है कि "मूल्य" फ़ील्ड की जाँच करके कौन अधिक है।

Answer 7

मैं GitHub की सलाह देता हूं : ऐरे सॉर्ट करें - एक सर्वोत्तम कार्यान्वयन sortByविधि जो श्वार्टज़ियन ट्रांसफ़ॉर्म का उपयोग करती है

लेकिन अभी के लिए हम इस दृष्टिकोण की कोशिश करने जा रहे हैं Gist: SortBy-old.js ।
आइए कुछ संपत्ति द्वारा ऑब्जेक्ट्स को व्यवस्थित करने में सक्षम होने के लिए एरे को सॉर्ट करने के लिए एक विधि बनाएं।

छँटाई समारोह बनाना

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

के लिए धन्यवाद @Ozesh उसकी प्रतिक्रिया से, के साथ गुण से संबंधित मुद्दे falsy मूल्यों तय हुई थी।

Comments

यह तब टूटता है जब कोई क्षेत्र अशक्त होता है।

— TSNev 13

यदि आप संख्याओं के माध्यम से छँटाई कर रहे हैं और आप वस्तुओं की सरणी के बीच में एक '0' का सामना कर रहे हैं, तो आप देख सकते हैं कि उपरोक्त कोड टूट गया है .. यहाँ इसके लिए एक त्वरित निर्धारण है: var checkNaN = function (value) { return Number.isNaN(Number(value)) ? 0 : value; } इसके बाद: वापसी फ़ंक्शन (सरणी, ओ) { .... a = _getItem.call (o, a); a = checkNaN (a); b = _getItem.call (ओ, बी); b = checkNaN (b); वापसी o.desc * (एक <b; -1: + (a> b)); });

— ओजेश

Answer 8

Lodash.sortBy का उपयोग करें , (निर्देश का उपयोग करते हुए, आप अपने HTML के शीर्ष पर cdn के लिए स्क्रिप्ट शामिल-टैग भी डाल सकते हैं )

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

घटते क्रम में

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

आरोही क्रम

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

Comments

याconst sortBy = require('lodash/sortBy'); let calendars = sortBy(calendarListResponse.items, cal => cal.summary);

— एमपीएन

यकीन नहीं होता है कि अगर लोडश ने हाल ही में इसका नाम बदल दिया है तो इसका नाम import { orderBy } from 'lodash'; ... ... return orderBy ( rows, 'fieldName' ).reverse();

— ऑर्डरबाय

Answer 9

यह एक सरल एक लाइन मूल्य () सॉर्ट फ़ंक्शन के माध्यम से प्राप्त किया जा सकता था । डेमो देखने के लिए नीचे कोड स्निपेट चलाएँ।

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

Answer 10

मैं पार्टी के लिए थोड़ा लेट हो गया लेकिन नीचे छंटनी का मेरा तर्क है।

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

Answer 11

जबकि मुझे पता है कि ओपी एक संख्या को क्रमबद्ध करना चाहता था, इस प्रश्न को तार के संबंध में इसी तरह के सवालों के जवाब के रूप में चिह्नित किया गया है। उस तथ्य के लिए, उपरोक्त उत्तर पाठ की एक सरणी को सॉर्ट करने पर विचार नहीं करते हैं जहां आवरण महत्वपूर्ण है। अधिकांश उत्तर स्ट्रिंग मान लेते हैं और उन्हें अपरकेस / लोअरकेस में परिवर्तित करते हैं और फिर एक या दूसरे तरीके से सॉर्ट करते हैं। जिन आवश्यकताओं का मैं पालन करता हूं वे सरल हैं:

• क्रमबद्ध रूप से 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" }));

Answer 12

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

Answer 13

यहाँ उपरोक्त सभी उत्तरों की एक परिणति है।

फिडल सत्यापन: 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();

        }));
    }


}

Comments

क्या आप कृपया बता सकते हैं कि क्या होने का महत्व है (संशोधन? -1: 1);

— TechTurtle

यह आदेश को उलटने के लिए है (आरोही बनाम उतरते हुए) रेव भाग केवल सामान्य परिणाम निकालता है जब रेव तर्क सही होता है। अन्यथा यह केवल 1 से कई होगा, जो सेट होने पर कुछ नहीं करता है, यह परिणाम को -1 से गुणा करेगा, जिससे परिणाम उत्पन्न होगा।

— बॉब

Answer 14

मैंने कुछ प्रकार की रेटिंग और कई क्षेत्रों में भी काम किया है:

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

Answer 15

हालांकि यह एक एकल सरणी को सॉर्ट करने के लिए एक ओवरकिल का एक सा है, यह प्रोटोटाइप फ़ंक्शन किसी भी कुंजी द्वारा जावास्क्रिप्ट कैप्शन को आरोही या अवरोही क्रम में क्रमबद्ध करने की अनुमति देता है, जिसमें नेस्टेड कुंजी , 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

Comments

मुझे यह जवाब बहुत पसंद है क्योंकि sortByसंक्षिप्त वाक्य रचना। नेस्टेड फ़ील्ड के साथ उपयोग करने में आसान है- महान कोड-पठनीयता को बनाए रखते हुए। धन्यवाद!

— मैनफ्रेड अर्बन

Answer 16

ECMAScript 6 के साथ StoBor के उत्तर को और अधिक संक्षिप्त किया जा सकता है:

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

Answer 17

मूल्य का अवरोही क्रम:

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

मूल्य के बढ़ते क्रम:

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

Answer 18

एक सरणी को छाँटने के लिए आपको एक तुलनित्र फ़ंक्शन को परिभाषित करना होगा। यह फ़ंक्शन हमेशा आपके इच्छित सॉर्टिंग पैटर्न या ऑर्डर (यानी आरोही या अवरोही) पर भिन्न होता है।

कुछ ऐसे फंक्शन बनाएं जो आरोही या अवरोही की तरह हो और जिसमें ऑब्जेक्ट या स्ट्रिंग या न्यूमेरिक वैल्यूज हों।

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

जैसा कि ऊपर का उपयोग करें sorterPriceAsc और sorterPriceDes विधि के साथ अपने सरणी के साथ वांछित कुंजी।

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

Answer 19

यदि आप Underscore.js का उपयोग करते हैं , तो सॉर्ट करने का प्रयास करें:

// price is of an integer type
_.sortBy(homes, "price"); 

// price is of a string type
_.sortBy(homes, function(home) {return parseInt(home.price);}); 

Answer 20

यहां "जावास्क्रिप्ट: द गुड पार्ट्स" पुस्तक से सुरुचिपूर्ण कार्यान्वयन का थोड़ा संशोधित संस्करण है।

नोट : के इस संस्करण में 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"}
// ]

Comments

क्या हम {"first":"Curly","last":"Howard", "property" : {"id" : "1"}}आईडी द्वारा सरणी के प्रकार को सॉर्ट कर सकते हैं ?

— विशाल कुमार साहू

हां, फ़ंक्शन को एक नया पैरामीटर लेने के लिए थोड़ा संशोधित करना होगा, कहते हैं, नेस्टनेम। फिर आप byनाम = "संपत्ति", नेस्टनेम = "आईडी" के साथ कॉल करते हैं

— पौराणिक

Answer 21

केवल तत्वों के एक सामान्य सरणी के लिए:

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

Answer 22

नीचे दिए गए कोड का उपयोग करके इनपुट के आधार पर एक फ़ंक्शन और सॉर्ट बनाएं

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

Answer 23

आप स्ट्रिंग तुलना के लिए string1.localeCompare (string2) का उपयोग कर सकते हैं

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

ध्यान दें कि localCompareमामला है में संवेदनशील

Answer 24

एक से अधिक सरणी ऑब्जेक्ट फ़ील्ड पर सॉर्ट करें। अपने फ़ील्ड नाम को 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;
}

Answer 25

आपको दो फ़ंक्शन की आवश्यकता होगी

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

Answer 26

यदि आप इसका उपयोग करना चाहते हैं तो मैंने हाल ही में आपके लिए इसे प्रबंधित करने के लिए एक सार्वभौमिक फ़ंक्शन लिखा है।

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

}

Answer 27

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

Answer 28

हाय इस लेख को पढ़ने के बाद, मैंने अपनी जरूरतों के लिए एक सॉर्टकैप्टर बनाया, जिसमें एक से अधिक जसन विशेषताओं की तुलना करने के लिए कार्यक्षमता है, और मैं इसे आपके साथ साझा करना चाहता हूं।

यह समाधान केवल आरोही क्रम में तार की तुलना करता है, लेकिन प्रत्येक विशेषता के समर्थन के लिए समाधान को आसान बढ़ाया जा सकता है: रिवर्स ऑर्डर, अन्य डेटा प्रकार, लोकेल, कास्टिंग आदि का उपयोग करने के लिए।

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

Answer 29

एक सरल कोड:

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

Answer 30

 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