मेरे पास जावास्क्रिप्ट ऑब्जेक्ट्स की एक सरणी है:

var objs = [ 
    { first_nom: 'Lazslo', last_nom: 'Jamf'     },
    { first_nom: 'Pig',    last_nom: 'Bodine'   },
    { first_nom: 'Pirate', last_nom: 'Prentice' }
];

मैं उन्हें जावास्क्रिप्ट में last_nom के मान से कैसे क्रमबद्ध कर सकता हूं?

मुझे sort(a,b) के बारे में पता है, लेकिन ऐसा लगता है कि यह केवल स्ट्रिंग्स और नंबरों पर काम करता है। क्या मुझे अपनी वस्तुओं में toString() विधि जोड़ने की आवश्यकता है?

3493
Tyrone Slothrop 15 जुलाई 2009, 07:17
7
यह स्क्रिप्ट आपको ऐसा करने की अनुमति देती है जब तक कि आप अपना खुद का तुलना फ़ंक्शन या सॉर्टर नहीं लिखना चाहते: thomasfrank.se/ Sorting_things.html
 – 
Baversjo
15 जुलाई 2009, 07:31
8
कृपया objs.sort((a, b) => a.last_nom > b.last_nom && 1 || -1)
 – 
artem
28 अप्रैल 2021, 08:14
फ़ंक्शन तुलना (ए, बी) {अगर (ए.अंतिम_नोम <बी.last_nom) {वापसी -1; } अगर (a.last_nom > b.last_nom ){ वापसी 1; } वापसी 0; } objs.sort (तुलना करें);
 – 
Ali NajafZadeh
3 अगस्त 2021, 19:56
1
यह मेरा जवाब है stackoverflow.com/a/67021585/7012450
 – 
artem
5 नवम्बर 2021, 09:18

32 जवाब

सबसे बढ़िया उत्तर

अपना खुद का तुलना फ़ंक्शन लिखना काफी आसान है:

function compare( a, b ) {
  if ( a.last_nom < b.last_nom ){
    return -1;
  }
  if ( a.last_nom > b.last_nom ){
    return 1;
  }
  return 0;
}

objs.sort( compare );

या इनलाइन (c/o Marco Demaio):

objs.sort((a,b) => (a.last_nom > b.last_nom) ? 1 : ((b.last_nom > a.last_nom) ? -1 : 0))
4812
meagar 29 मई 2021, 07:14
521
या इनलाइन: objs.sort(function(a,b) {रिटर्न (a.last_nom > b.last_nom) ? 1 : ((b.last_nom > a.last_nom) ? -1 : 0);} );
 – 
Marco Demaio
24 फरवरी 2010, 21:29
39
आधिकारिक दस्तावेज़: developer.mozilla.org/en/JavaScript/Reference/Global_Objects /…
 – 
mikemaccana
18 मई 2012, 13:11
237
return a.last_nom.localeCompare(b.last_nom) भी काम करेगा।
 – 
Cerbrus
14 फरवरी 2013, 14:37
173
उन लोगों के लिए जो एक प्रकार की तलाश कर रहे हैं जहां फ़ील्ड संख्यात्मक है, तुलना फ़ंक्शन बॉडी: return a.value - b.value; (एएससी)
 – 
Andre Figueiredo
8 जिंदा 2014, 16:06
2
कृपया संक्षिप्त कोड लिखें objs.sort((a, b) => a.last_nom > b.last_nom && 1 || -1)
 – 
artem
28 अप्रैल 2021, 08:12

आप एक डायनामिक सॉर्ट फ़ंक्शन भी बना सकते हैं जो आपके द्वारा पास किए गए मान के आधार पर ऑब्जेक्ट को सॉर्ट करता है:

function dynamicSort(property) {
    var sortOrder = 1;
    if(property[0] === "-") {
        sortOrder = -1;
        property = property.substr(1);
    }
    return function (a,b) {
        /* next line works with strings and numbers, 
         * and you may want to customize it to your needs
         */
        var result = (a[property] < b[property]) ? -1 : (a[property] > b[property]) ? 1 : 0;
        return result * sortOrder;
    }
}

तो आपके पास इस तरह की वस्तुओं की एक सरणी हो सकती है:

var People = [
    {Name: "Name", Surname: "Surname"},
    {Name:"AAA", Surname:"ZZZ"},
    {Name: "Name", Surname: "AAA"}
];

... और यह तब काम करेगा जब आप करेंगे:

People.sort(dynamicSort("Name"));
People.sort(dynamicSort("Surname"));
People.sort(dynamicSort("-Surname"));

असल में यह पहले से ही सवाल का जवाब देता है। नीचे भाग लिखा गया है क्योंकि कई लोगों ने मुझसे संपर्क किया, शिकायत की कि यह कई मापदंडों के साथ काम नहीं करता

एकाधिक पैरामीटर

आप एकाधिक सॉर्ट पैरामीटर के साथ सॉर्ट फ़ंक्शन जेनरेट करने के लिए नीचे दिए गए फ़ंक्शन का उपयोग कर सकते हैं।

function dynamicSortMultiple() {
    /*
     * save the arguments object as it will be overwritten
     * note that arguments object is an array-like object
     * consisting of the names of the properties to sort by
     */
    var props = arguments;
    return function (obj1, obj2) {
        var i = 0, result = 0, numberOfProperties = props.length;
        /* try getting a different result from 0 (equal)
         * as long as we have extra properties to compare
         */
        while(result === 0 && i < numberOfProperties) {
            result = dynamicSort(props[i])(obj1, obj2);
            i++;
        }
        return result;
    }
}

जो आपको ऐसा कुछ करने में सक्षम करेगा:

People.sort(dynamicSortMultiple("Name", "-Surname"));

उपवर्गीकरण सरणी

हमारे बीच भाग्यशाली के लिए जो ES6 का उपयोग कर सकता है, जो मूल वस्तुओं को विस्तारित करने की अनुमति देता है:

class MyArray extends Array {
    sortBy(...args) {
        return this.sort(dynamicSortMultiple(...args));
    }
}

यह इसे सक्षम करेगा:

MyArray.from(People).sortBy("Name", "-Surname");
973
Ege Özcan 13 पद 2020, 12:49
2
अच्छा। अब इस उत्तर का टाइपप्रति संस्करण उपलब्ध है: stackoverflow.com/a/68279093/8910547। (प्रकार) सुरक्षित रहें! मैं
 – 
Inigo
7 जुलाई 2021, 05:30

ES6/ES2015 या बाद में आप इस तरह से कर सकते हैं:

objs.sort((a, b) => a.last_nom.localeCompare(b.last_nom));

ES6/ES2015 से पहले

objs.sort(function(a, b) {
    return a.last_nom.localeCompare(b.last_nom)
});
709
meagar 29 मई 2021, 07:31
39
यह जेएस 1.1 के बाद से उपलब्ध है, इसके लिए मोटा तीर टुकड़ा ES6/2015 टुकड़ा है। लेकिन फिर भी बहुत उपयोगी, और मेरी राय में सबसे अच्छा जवाब
 – 
Jon Harding
22 फरवरी 2016, 23:30
21
@PratikKelwalkar: यदि आपको रिवर्स की आवश्यकता है तो इसे केवल a और b तुलना स्विच करें: objs.sort((a, b) => b.last_nom.localeCompare(a.last_nom));
 – 
Vlad Bezden
26 मई 2016, 21:24
यदि मान संख्यात्मक हैं, तो आपको localeCompare की आवश्यकता नहीं है। आप मानक > ऑपरेटर का उपयोग कर सकते हैं - जैसा कि @ muasif80 द्वारा उत्तर में उल्लेख किया गया है - stackoverflow.com/a/67992215/6908282
 – 
Gangula
29 अक्टूबर 2021, 22:29

समझ में नहीं आता कि लोग इसे इतना जटिल क्यों बना देते हैं:

objs.sort(function(a, b){
  return a.last_nom > b.last_nom;
});

सख्त इंजन के लिए:

objs.sort(function(a, b){
  return a.last_nom == b.last_nom ? 0 : +(a.last_nom > b.last_nom) || -1;
});

इसे उल्टे वर्णानुक्रम से क्रमबद्ध करने के लिए ऑपरेटर को स्वैप करें।

179
p3lim 22 अप्रैल 2014, 23:25
16
यह वास्तव में सही नहीं है क्योंकि सॉर्ट में प्रयुक्त फ़ंक्शन -1, 0, या 1 वापस आना चाहिए, लेकिन उपरोक्त फ़ंक्शन एक बूलियन देता है। क्रम क्रोम में ठीक काम करता है लेकिन उदाहरण के लिए फैंटमजेएस में विफल रहता है। देखें code.google.com/p/phantomjs/issues/detail?id =1090
 – 
schup
22 अप्रैल 2014, 19:05
कुछ इंजन मूर्खता के लिए जिम्मेदार हैं, इस तरह से इसका शोषण किया जा रहा था। मैंने अपना उत्तर उचित संस्करण के साथ अपडेट कर दिया है।
 – 
p3lim
22 अप्रैल 2014, 23:23
19
मैं पहले संस्करण को निकालने के लिए संपादन का सुझाव दूंगा। इसका अधिक संक्षिप्त इसलिए अधिक आकर्षक लगता है, लेकिन यह काम नहीं करता है, कम से कम मज़बूती से नहीं। यदि कोई इसे एक ब्राउज़र में आज़माता है और यह काम करता है, तो उन्हें यह एहसास भी नहीं हो सकता है कि उन्हें कोई समस्या है (विशेषकर यदि उन्होंने टिप्पणियों को नहीं पढ़ा है)। दूसरा संस्करण ठीक से काम करता है इसलिए वास्तव में पहले की कोई आवश्यकता नहीं है।
 – 
Kate
11 मार्च 2016, 18:01
2
मैंने वास्तव में पहले "थोड़ा गलत" संस्करण होने की सराहना की, क्योंकि सख्त कार्यान्वयन को पार्स करने और समझने में कुछ सेकंड लगते हैं और इसके बिना बहुत कठिन होगा।
 – 
Aaron Sherman
24 जून 2016, 19:50
1
बस यह करें: if(a.count == b.count) return a.name > b.name; else return a.count > b.count;
 – 
p3lim
7 मई 2017, 20:16

यदि आपके पास डुप्लीकेट अंतिम नाम हैं तो आप उन्हें पहले नाम से क्रमबद्ध कर सकते हैं-

obj.sort(function(a,b){
  if(a.last_nom< b.last_nom) return -1;
  if(a.last_nom >b.last_nom) return 1;
  if(a.first_nom< b.first_nom) return -1;
  if(a.first_nom >b.first_nom) return 1;
  return 0;
});
81
BadFeelingAboutThis 29 अप्रैल 2014, 22:35
-1 या 1 लौटने का क्या मतलब है? मैं समझता हूं कि -1 का शाब्दिक अर्थ है कि केवल सिंटैक्स द्वारा A, B से कम है, लेकिन 1 या -1 का उपयोग क्यों करें? मैं देखता हूं कि हर कोई उन नंबरों का उपयोग रिटर्न वैल्यू के रूप में कर रहा है, लेकिन क्यों? धन्यवाद।
 – 
Chris22
22 अगस्त 2018, 09:15
1
लौटाई गई ऋणात्मक संख्या का अर्थ है कि b को सरणी में a के बाद आना चाहिए। यदि कोई धनात्मक संख्या लौटाई जाती है, तो इसका अर्थ है कि a, b के बाद आना चाहिए। अगर 0 लौटाया जाता है, तो इसका मतलब है कि उन्हें बराबर माना जाता है। आप हमेशा दस्तावेज़ पढ़ सकते हैं: developer.mozilla .org/en-US/docs/Web/JavaScript/Reference/…
 – 
BadFeelingAboutThis
22 अगस्त 2018, 19:54
धन्यवाद, स्पष्टीकरण और लिंक के लिए। मानो या न मानो, मैंने यहां यह पूछने से पहले 1, 0, -1 का उपयोग करके कोड के विभिन्न स्निपेट को गुगल किया था। मुझे वह जानकारी नहीं मिल रही थी जिसकी मुझे आवश्यकता थी।
 – 
Chris22
22 अगस्त 2018, 20:07

प्रोटोटाइप वंशानुक्रम का उपयोग करके इस समस्या का सरल और त्वरित समाधान:

Array.prototype.sortBy = function(p) {
  return this.slice(0).sort(function(a,b) {
    return (a[p] > b[p]) ? 1 : (a[p] < b[p]) ? -1 : 0;
  });
}

उदाहरण / उपयोग

objs = [{age:44,name:'vinay'},{age:24,name:'deepak'},{age:74,name:'suresh'}];

objs.sortBy('age');
// Returns
// [{"age":24,"name":"deepak"},{"age":44,"name":"vinay"},{"age":74,"name":"suresh"}]

objs.sortBy('name');
// Returns
// [{"age":24,"name":"deepak"},{"age":74,"name":"suresh"},{"age":44,"name":"vinay"}]

अपडेट करें: अब मूल सरणी को संशोधित नहीं करता है।

58
Web_Designer 16 मई 2015, 00:45
7
यह सिर्फ एक और सरणी नहीं लौटाता है। लेकिन वास्तव में मूल प्रकार!.
 – 
Vinay Aggarwal
21 जुलाई 2012, 09:43
1
यदि आप यह सुनिश्चित करना चाहते हैं कि आप संख्याओं के साथ एक प्राकृतिक प्रकार का उपयोग कर रहे हैं (यानी, 0,1,2,10,11 आदि...) तो मूलांक सेट के साथ parseInt का उपयोग करें। developer.mozilla.org/en-US/docs/ वेब/जावास्क्रिप्ट/संदर्भ/… तो: वापसी (parseInt(a[p],10) > parseInt(b[p],10))? 1 : (parseInt(a[p],10)  – 
Paul
11 मई 2015, 22:14
इसे ठीक करने के लिए धन्यवाद। लेकिन मुझे लगता है कि इस संवेदीकरण को करने के लिए सॉर्ट फ़ंक्शन बनाने के बजाय, यह बेहतर है कि हम डेटा प्रकारों को ठीक करने के लिए एक अलग कार्य करें। क्योंकि सॉर्ट फ़ंक्शन यह नहीं बता सकता कि किस संपत्ति में किस प्रकार का डेटा होगा। :)
 – 
Vinay Aggarwal
21 मई 2015, 19:55
बहुत अच्छा। asc/desc प्रभाव प्राप्त करने के लिए तीरों को उल्टा करें।
 – 
Abdul Sadik Yalcin
15 नवम्बर 2017, 18:08
8
कभी भी, किसी ऐसे समाधान का सुझाव न दें जो किसी मूल वस्तु के प्रोटोटाइप को संशोधित करता हो
 – 
pbanka
27 अक्टूबर 2018, 03:17

2018 तक बहुत छोटा और सुरुचिपूर्ण समाधान है। महज प्रयोग करें। Array.prototype.sort() .

उदाहरण:

var items = [
  { name: 'Edward', value: 21 },
  { name: 'Sharpe', value: 37 },
  { name: 'And', value: 45 },
  { name: 'The', value: -12 },
  { name: 'Magnetic', value: 13 },
  { name: 'Zeros', value: 37 }
];

// sort by value
items.sort(function (a, b) {
  return a.value - b.value;
});
60
0leg 4 जून 2018, 18:24
11
प्रश्न में संख्याओं के विपरीत तुलना के लिए स्ट्रिंग्स का उपयोग किया गया था। आपका उत्तर संख्याओं के आधार पर छाँटने के लिए बहुत अच्छा काम करता है, लेकिन स्ट्रिंग द्वारा तुलना के लिए इतना अच्छा नहीं है।
 – 
smcstewart
18 जून 2018, 13:02
ऑब्जेक्ट की विशेषताओं (संख्या इस मामले में) की तुलना करने के लिए प्रयुक्त a.value - b.value डेटा के विभिन्न समयों के लिए अपनाया जा सकता है। उदाहरण के लिए, रेगेक्स का उपयोग पड़ोसी स्ट्रिंग्स की प्रत्येक जोड़ी की तुलना करने के लिए किया जा सकता है।
 – 
0leg
26 मार्च 2019, 12:10
1
मैं इस तरह से तारों की तुलना करने के लिए रेगेक्स का उपयोग करने के लिए यहां एक उदाहरण देखना चाहता हूं।
 – 
Bob Stein
28 मार्च 2019, 14:30
यदि आपको इसे आईडी द्वारा क्रमबद्ध करने की आवश्यकता है तो यह कार्यान्वयन काफी अच्छा है। हाँ, आपने पड़ोसी स्ट्रिंग की तुलना करने के लिए रेगेक्स का उपयोग करने का सुझाव दिया है जो समाधान को और अधिक जटिल बनाता है जबकि इस सरलीकृत संस्करण का उद्देश्य अन्यथा होगा यदि रेगेक्स का उपयोग दिए गए समाधान के साथ किया जाता है। सरलता सर्वोत्तम है।
 – 
surendrapanday
10 पद 2019, 11:29

कस्टम तुलना फ़ंक्शन का उपयोग करने के बजाय, आप कस्टम toString() विधि के साथ एक ऑब्जेक्ट प्रकार भी बना सकते हैं (जिसे डिफ़ॉल्ट तुलना फ़ंक्शन द्वारा लागू किया जाता है):

function Person(firstName, lastName) {
    this.firtName = firstName;
    this.lastName = lastName;
}

Person.prototype.toString = function() {
    return this.lastName + ', ' + this.firstName;
}

var persons = [ new Person('Lazslo', 'Jamf'), ...]
persons.sort();
33
Christoph 15 जुलाई 2009, 11:21

आप उपयोग कर सकते हैं सबसे आसान तरीका: लोदश

(https://lodash.com/docs/4.17.10#orderBy)

यह विधि _.sortBy की तरह है, सिवाय इसके कि यह पुनरावृत्तियों के क्रमबद्ध क्रम को निर्दिष्ट करने की अनुमति देता है। यदि आदेश निर्दिष्ट नहीं हैं, तो सभी मान आरोही क्रम में क्रमबद्ध हैं। अन्यथा, अवरोही के लिए "desc" का क्रम निर्दिष्ट करें या संगत मानों के आरोही क्रम के लिए "asc" निर्दिष्ट करें।

तर्क

संग्रह (ऐरे | ऑब्जेक्ट): संग्रह को फिर से शुरू करना है। [iteratees=[_.identity]] (ऐरे [] | फंक्शन [] | ऑब्जेक्ट [] | स्ट्रिंग []): क्रमबद्ध करने के लिए पुनरावृत्त। [आदेश] (स्ट्रिंग []): पुनरावृत्तियों के क्रमबद्ध क्रम।

रिटर्न

(ऐरे): नया सॉर्ट किया गया ऐरे देता है।


var _ = require('lodash');
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":"6",
     "city":"Dallas",
     "state":"TX",
     "zip":"75000",
     "price":"556699"},
    {"h_id":"5",
     "city":"New York",
     "state":"NY",
     "zip":"00010",
     "price":"962500"}
    ];
    
_.orderBy(homes, ['city', 'state', 'zip'], ['asc', 'desc', 'asc']);
35
turivishal 23 अप्रैल 2021, 16:23

पुराना उत्तर जो सही नहीं है:

arr.sort((a, b) => a.name > b.name)

अपडेट करें

ब्यूचैम्प की टिप्पणी से:

arr.sort((a, b) => a.name < b.name ? -1 : (a.name > b.name ? 1 : 0))

अधिक पठनीय प्रारूप:

arr.sort((a, b) => {
  if (a.name < b.name) return -1
  return a.name > b.name ? 1 : 0
})

नेस्टेड टर्नरी के बिना:

arr.sort((a, b) => a.name < b.name ? - 1 : Number(a.name > b.name))

व्याख्या: Number(), true को 1 और false से 0 को कास्ट करेगा।

56
Damian Pavlica 25 पद 2019, 00:38
1
यह काम करता है, लेकिन परिणाम किसी कारण से अस्थिर है
 – 
TitanFighter
3 फरवरी 2018, 22:55
1
नहीं यह नहीं होगा। आप तार घटाना नहीं कर सकते।
 – 
Patrick Roberts
18 जुलाई 2018, 12:23
16
इसे यह करना चाहिए: arr.sort((a, b) => a.name < b.name ? -1 : (a.name > b.name ? 1 : 0))
 – 
Jean-François Beauchamp
29 अगस्त 2018, 18:33
3
@ जीन-फ्रांस्वा बेउचैम्प, आपका समाधान पूरी तरह से ठीक और बहुत बेहतर काम करता है।
 – 
Ahsan
22 जिंदा 2019, 16:49
2
arr.sort((a, b) => a.name > b.name ? 1 : -1 काम क्यों नहीं करेगा? स्ट्रिंग्स के लिए मैंने परीक्षण किया है कि यह बहुत अच्छा काम करता है। यदि आप केस असंवेदनशील चाहते हैं तो a.name.toLowerCase() और b.name.toLowerCase() का उपयोग करें
 – 
muasif80
15 जून 2021, 22:08

Lodash.js (अंडरस्कोर का सुपरसेट। जेएस)

तर्क के हर साधारण टुकड़े के लिए एक ढांचा नहीं जोड़ना अच्छा है, लेकिन अच्छी तरह से परीक्षण किए गए उपयोगिता ढांचे पर भरोसा करना विकास को गति दे सकता है और बग की मात्रा को कम कर सकता है।

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

ओपी की समस्या को इस प्रकार हल किया जा सकता है:

const sortedObjs = _.sortBy(objs, 'last_nom');

और जानकारी? उदा. हमारे पास निम्नलिखित नेस्टेड वस्तु है:

const users = [
  { 'user': {'name':'fred', 'age': 48}},
  { 'user': {'name':'barney', 'age': 36 }},
  { 'user': {'name':'wilma'}},
  { 'user': {'name':'betty', 'age': 32}}
];

अब हम पथ निर्दिष्ट करने के लिए _.property शॉर्टहैंड user.age का उपयोग कर सकते हैं जिस संपत्ति का मिलान किया जाना चाहिए। हम उपयोगकर्ता वस्तुओं को नेस्टेड आयु संपत्ति द्वारा क्रमबद्ध करेंगे। हाँ, यह नेस्टेड संपत्ति मिलान की अनुमति देता है!

const sortedObjs = _.sortBy(users, ['user.age']);

इसे उलटना चाहते हैं? कोई दिक्कत नहीं है। _.reverse का उपयोग करें।

const sortedObjs = _.reverse(_.sortBy(users, ['user.age']));

श्रृंखला का उपयोग करके दोनों को जोड़ना चाहते हैं?

const { chain } = require('lodash');
const sortedObjs = chain(users).sortBy('user.age').reverse().value();

या आप कब श्रृंखला के ऊपर प्रवाह पसंद करते हैं

const { flow, reverse, sortBy } = require('lodash/fp');
const sortedObjs = flow([sortBy('user.age'), reverse])(users); 
39
Nico Van Belle 4 मार्च 2020, 12:41

यहां कई अच्छे उत्तर हैं, लेकिन मैं यह बताना चाहूंगा कि बहुत अधिक जटिल छँटाई प्राप्त करने के लिए उन्हें बहुत सरलता से बढ़ाया जा सकता है। केवल एक चीज जो आपको करनी है वह यह है कि OR ऑपरेटर का उपयोग इस तरह के तुलना कार्यों को श्रृंखलाबद्ध करने के लिए किया जाता है:

objs.sort((a,b)=> fn1(a,b) || fn2(a,b) || fn3(a,b) )

जहां fn1, fn2, ... ऐसे सॉर्ट फ़ंक्शन हैं जो [-1,0,1] लौटाते हैं। इसका परिणाम "fn1 द्वारा छँटाई", "fn2 द्वारा छँटाई" है जो SQL में ORDER BY के बराबर है।

यह समाधान || ऑपरेटर के व्यवहार पर आधारित है जो पहली बार मूल्यांकित अभिव्यक्ति जिसे सत्य में बदला जा सकता है

सबसे सरल फ़ॉर्म में इस तरह केवल एक इनलाइन फ़ंक्शन है:

// ORDER BY last_nom
objs.sort((a,b)=> a.last_nom.localeCompare(b.last_nom) )

last_nom,first_nom सॉर्ट ऑर्डर के साथ दो चरण होने पर ऐसा दिखेगा:

// ORDER_BY last_nom, first_nom
objs.sort((a,b)=> a.last_nom.localeCompare(b.last_nom) || 
                  a.first_nom.localeCompare(b.first_nom)  )

एक सामान्य तुलना फ़ंक्शन कुछ इस तरह हो सकता है:

// ORDER BY <n>
let cmp = (a,b,n)=>a[n].localeCompare(b[n])

इस फ़ंक्शन को संख्यात्मक क्षेत्रों, केस सेंसिटिविटी, आर्बिटरी डेटाटाइप आदि का समर्थन करने के लिए बढ़ाया जा सकता है।

आप उन्हें प्राथमिकता के आधार पर उनका उपयोग कर सकते हैं:

// ORDER_BY last_nom, first_nom
objs.sort((a,b)=> cmp(a,b, "last_nom") || cmp(a,b, "first_nom") )
// ORDER_BY last_nom, first_nom DESC
objs.sort((a,b)=> cmp(a,b, "last_nom") || -cmp(a,b, "first_nom") )
// ORDER_BY last_nom DESC, first_nom DESC
objs.sort((a,b)=> -cmp(a,b, "last_nom") || -cmp(a,b, "first_nom") )

यहाँ मुद्दा यह है कि कार्यात्मक दृष्टिकोण के साथ शुद्ध जावास्क्रिप्ट बाहरी पुस्तकालयों या जटिल कोड के बिना आपको एक लंबा रास्ता तय कर सकता है। यह बहुत प्रभावी भी है, क्योंकि कोई स्ट्रिंग पार्सिंग करने की आवश्यकता नहीं है

30
Tero Tolonen 5 मई 2016, 14:36

उदाहरण

objs.sort(sortBy('last_nom'));

स्क्रिप्ट:

/**
 * @description
 * Returns a function which will sort an
 * array of objects by the given key.
 *
 * @param  {String}  key
 * @param  {Boolean} reverse
 * @return {Function}
 */
const sortBy = (key, reverse) => {

  // Move smaller items towards the front
  // or back of the array depending on if
  // we want to sort the array in reverse
  // order or not.
  const moveSmaller = reverse ? 1 : -1;

  // Move larger items towards the front
  // or back of the array depending on if
  // we want to sort the array in reverse
  // order or not.
  const moveLarger = reverse ? -1 : 1;

  /**
   * @param  {*} a
   * @param  {*} b
   * @return {Number}
   */
  return (a, b) => {
    if (a[key] < b[key]) {
      return moveSmaller;
    }
    if (a[key] > b[key]) {
      return moveLarger;
    }
    return 0;
  };
};
26
Jamie Mason 21 मार्च 2019, 20:18
इसे तोड़ने के लिए धन्यवाद, मैं यह समझने की कोशिश कर रहा हूं कि अंकों 1, 0, -1 का उपयोग क्रमबद्ध करने के लिए क्यों किया जाता है। यहां तक ​​​​कि ऊपर आपके स्पष्टीकरण के साथ, जो बहुत अच्छा लग रहा है-- मैं अभी भी इसे पूरी तरह समझ नहीं पा रहा हूं। मैं हमेशा -1 के बारे में सोचता हूं जैसे सरणी लंबाई संपत्ति का उपयोग करते समय, यानी: arr.length = -1 का अर्थ है कि आइटम नहीं मिला है। मैं शायद यहां चीजों को मिला रहा हूं, लेकिन क्या आप मुझे यह समझने में मदद कर सकते हैं कि अंक 1, 0, -1 का उपयोग क्रम निर्धारित करने के लिए क्यों किया जाता है? धन्यवाद।
 – 
Chris22
22 अगस्त 2018, 09:23
1
यह पूरी तरह से सटीक नहीं है, लेकिन इसके बारे में इस तरह सोचने में मदद मिल सकती है: array.sort को दिया गया फ़ंक्शन सरणी में प्रत्येक आइटम के लिए एक बार कॉल किया जाता है, जैसा कि "a" नामक तर्क है। प्रत्येक फ़ंक्शन कॉल का रिटर्न वैल्यू यह है कि आइटम "ए" की अनुक्रमणिका (वर्तमान स्थिति संख्या) को अगले आइटम "बी" की तुलना में कैसे बदला जाना चाहिए। सूचकांक सरणी के क्रम को निर्धारित करता है (0, 1, 2 आदि) इसलिए यदि "ए" इंडेक्स 5 पर है और आप -1 पर लौटते हैं तो 5 + -1 == 4 (इसे आगे की ओर ले जाएं) 5 + 0 == 5 (इसे वहीं रखें जहां यह है) आदि। यह हर बार 2 पड़ोसियों की तुलना करते हुए सरणी पर चलता है जब तक कि यह अंत तक नहीं पहुंच जाता, एक क्रमबद्ध सरणी छोड़कर।
 – 
Jamie Mason
23 अगस्त 2018, 12:09
इसे और समझाने के लिए समय निकालने के लिए धन्यवाद। तो अपने स्पष्टीकरण और MDN Array.prototype का उपयोग करके .sort, मैं आपको बताऊंगा कि मैं इसके बारे में क्या सोच रहा हूं: a और b की तुलना में, यदि a b से बड़ा है a के सूचकांक में 1 और इसे b के पीछे रखें, यदि a b से कम है, तो a से 1 घटाएं और b के सामने रखें। b. यदि a और b समान हैं, तो a में 0 जोड़ें और इसे वहीं छोड़ दें।
 – 
Chris22
23 अगस्त 2018, 19:28

मैंने इस विशेष दृष्टिकोण का सुझाव नहीं देखा है, इसलिए यहां एक संक्षिप्त तुलना विधि है जिसका उपयोग मैं string और number दोनों प्रकारों के लिए करना चाहता हूं:

const objs = [ 
  { first_nom: 'Lazslo', last_nom: 'Jamf'     },
  { first_nom: 'Pig',    last_nom: 'Bodine'   },
  { first_nom: 'Pirate', last_nom: 'Prentice' }
];

const sortBy = fn => {
  const cmp = (a, b) => -(a < b) || +(a > b);
  return (a, b) => cmp(fn(a), fn(b));
};

const getLastName = o => o.last_nom;
const sortByLastName = sortBy(getLastName);

objs.sort(sortByLastName);
console.log(objs.map(getLastName));

sortBy() की व्याख्या

sortBy() एक fn स्वीकार करता है जो तुलना में उपयोग करने के लिए किसी ऑब्जेक्ट से एक मान का चयन करता है, और एक फ़ंक्शन देता है जिसे Array.prototype.sort()। इस उदाहरण में, हम o.last_nom की तुलना कर रहे हैं। जब भी हमें दो वस्तुएँ प्राप्त होती हैं जैसे

a = { first_nom: 'Lazslo', last_nom: 'Jamf' }
b = { first_nom: 'Pig', last_nom: 'Bodine' }

हम उनकी तुलना (a, b) => cmp(fn(a), fn(b)) से करते हैं। मान लें कि

fn = o => o.last_nom

हम तुलना फ़ंक्शन को (a, b) => cmp(a.last_nom, b.last_nom) तक बढ़ा सकते हैं। जिस तरह से लॉजिकल OR (||) जावास्क्रिप्ट में काम करता है, cmp(a.last_nom, b.last_nom) बराबर है

if (a.last_nom < b.last_nom) return -1;
if (a.last_nom > b.last_nom) return 1;
return 0;

संयोग से, इसे अन्य भाषाओं में तीन-तरफा तुलना "स्पेसशिप" (<=>) ऑपरेटर कहा जाता है।

अंत में, यहाँ तीर फ़ंक्शंस का उपयोग किए बिना ES5-संगत सिंटैक्स है:

var objs = [ 
  { first_nom: 'Lazslo', last_nom: 'Jamf'     },
  { first_nom: 'Pig',    last_nom: 'Bodine'   },
  { first_nom: 'Pirate', last_nom: 'Prentice' }
];

function sortBy(fn) {
  function cmp(a, b) { return -(a < b) || +(a > b); }
  return function (a, b) { return cmp(fn(a), fn(b)); };
}

function getLastName(o) { return o.last_nom; }
var sortByLastName = sortBy(getLastName);

objs.sort(sortByLastName);
console.log(objs.map(getLastName));
35
Patrick Roberts 9 जुलाई 2020, 18:38
मुझे यह तरीका पसंद है लेकिन मुझे लगता है कि -(fa < fb) || +(fa > fb) के शॉर्टहैंड का उपयोग करना यहां एक गलती है। कोड की एक पंक्ति में संघनित होने वाले कई कथन हैं। विकल्प, एक if कथन के साथ लिखा गया है, जो काफी संक्षिप्त होते हुए भी अधिक पठनीय होगा। मुझे लगता है कि सुंदरता के लिए पठनीयता का त्याग करना एक गलती है।
 – 
MSOACC
9 जुलाई 2020, 14:02
हे पैट्रिक, मुझे आपका उत्तर पसंद है लेकिन यह केवल अंग्रेज़ी वर्णों (const cmp = (a, b) => -(a < b) || +(a > b);) के साथ ठीक से काम करेगा ["ä", "a", "c", "b"].sort(cmp) => ["a", "b", "c", "ä"] के बारे में सोचें, जहां ä को अंत तक धकेला गया है। इसके बजाय आपको शायद तुलना फ़ंक्शन को अपडेट करना चाहिए: const cmp = (a, b) => a.localeCompare(b); => ["a", "ä", "b", "c"] चीयर्स और उत्तर के लिए धन्यवाद ;-)
 – 
rjanjic
9 अक्टूबर 2020, 16:48
प्रतिपुष्टि के लिए धन्यवाद। मुझे पता है कि यह यूनिकोड में वर्ण के कोड बिंदु के आधार पर छाँटता है। हालांकि इसे localeCompare में बदलने से संख्याओं को क्रमबद्ध करने की क्षमता समाप्त हो जाती है, और यह काफी धीमा भी है।
 – 
Patrick Roberts
9 अक्टूबर 2020, 22:22

मुझे पता है कि यह प्रश्न बहुत पुराना है, लेकिन मुझे मेरे जैसा कोई कार्यान्वयन नहीं दिखाई दिया।
यह संस्करण श्वार्ट्ज़ियन ट्रांसफ़ॉर्म मुहावरे पर आधारित है।

function sortByAttribute(array, ...attrs) {
  // generate an array of predicate-objects contains
  // property getter, and descending indicator
  let predicates = attrs.map(pred => {
    let descending = pred.charAt(0) === '-' ? -1 : 1;
    pred = pred.replace(/^-/, '');
    return {
      getter: o => o[pred],
      descend: descending
    };
  });
  // schwartzian transform idiom implementation. aka: "decorate-sort-undecorate"
  return array.map(item => {
    return {
      src: item,
      compareValues: predicates.map(predicate => predicate.getter(item))
    };
  })
  .sort((o1, o2) => {
    let i = -1, result = 0;
    while (++i < predicates.length) {
      if (o1.compareValues[i] < o2.compareValues[i]) result = -1;
      if (o1.compareValues[i] > o2.compareValues[i]) result = 1;
      if (result *= predicates[i].descend) break;
    }
    return result;
  })
  .map(item => item.src);
}

यहां एक उदाहरण दिया गया है कि इसका उपयोग कैसे करें:

let games = [
  { name: 'Mashraki',          rating: 4.21 },
  { name: 'Hill Climb Racing', rating: 3.88 },
  { name: 'Angry Birds Space', rating: 3.88 },
  { name: 'Badland',           rating: 4.33 }
];

// sort by one attribute
console.log(sortByAttribute(games, 'name'));
// sort by mupltiple attributes
console.log(sortByAttribute(games, '-rating', 'name'));
23
a8m 6 मई 2020, 11:38

वस्तुओं की जटिल सरणियों को छाँटना (अधिक)

चूंकि आप शायद इस सरणी जैसी अधिक जटिल डेटा संरचनाओं का सामना करते हैं, इसलिए मैं समाधान का विस्तार करूंगा।

टीएल; डीआर

@ege-Özcan पर आधारित अधिक प्लग करने योग्य संस्करण हैं उत्तर

संकट

मैंने नीचे का सामना किया और इसे बदल नहीं सका। मैं भी वस्तु को अस्थायी रूप से समतल नहीं करना चाहता था। न ही मैं अंडरस्कोर / लॉश का उपयोग करना चाहता था, मुख्य रूप से प्रदर्शन कारणों और इसे स्वयं लागू करने के लिए।

var People = [
   {Name: {name: "Name", surname: "Surname"}, Middlename: "JJ"},
   {Name: {name: "AAA", surname: "ZZZ"}, Middlename:"Abrams"},
   {Name: {name: "Name", surname: "AAA"}, Middlename: "Wars"}
];

लक्ष्य

लक्ष्य इसे प्राथमिक रूप से People.Name.name द्वारा और दूसरा People.Name.surname द्वारा क्रमबद्ध करना है

बाधाएं

अब, बेस समाधान में गतिशील रूप से सॉर्ट करने के लिए गुणों की गणना करने के लिए ब्रैकेट नोटेशन का उपयोग करता है। यहां, हालांकि, हमें गतिशील रूप से भी ब्रैकेट नोटेशन का निर्माण करना होगा, क्योंकि आप उम्मीद करेंगे कि People['Name.name'] जैसे कुछ काम करेंगे - जो नहीं करता है।

दूसरी ओर, केवल People['Name']['name'] करना स्थिर है और केवल आपको n-वें स्तर से नीचे जाने की अनुमति देता है।

समाधान

यहां मुख्य जोड़ ऑब्जेक्ट ट्री के नीचे चलना होगा और अंतिम पत्ते के मूल्य को निर्धारित करना होगा, साथ ही साथ किसी भी मध्यस्थ पत्ते को भी निर्दिष्ट करना होगा।

var People = [
   {Name: {name: "Name", surname: "Surname"}, Middlename: "JJ"},
   {Name: {name: "AAA", surname: "ZZZ"}, Middlename:"Abrams"},
   {Name: {name: "Name", surname: "AAA"}, Middlename: "Wars"}
];

People.sort(dynamicMultiSort(['Name','name'], ['Name', '-surname']));
// Results in...
// [ { Name: { name: 'AAA', surname: 'ZZZ' }, Middlename: 'Abrams' },
//   { Name: { name: 'Name', surname: 'Surname' }, Middlename: 'JJ' },
//   { Name: { name: 'Name', surname: 'AAA' }, Middlename: 'Wars' } ]

// same logic as above, but strong deviation for dynamic properties 
function dynamicSort(properties) {
  var sortOrder = 1;
  // determine sort order by checking sign of last element of array
  if(properties[properties.length - 1][0] === "-") {
    sortOrder = -1;
    // Chop off sign
    properties[properties.length - 1] = properties[properties.length - 1].substr(1);
  }
  return function (a,b) {
    propertyOfA = recurseObjProp(a, properties)
    propertyOfB = recurseObjProp(b, properties)
    var result = (propertyOfA < propertyOfB) ? -1 : (propertyOfA > propertyOfB) ? 1 : 0;
    return result * sortOrder;
  };
}

/**
 * Takes an object and recurses down the tree to a target leaf and returns it value
 * @param  {Object} root - Object to be traversed.
 * @param  {Array} leafs - Array of downwards traversal. To access the value: {parent:{ child: 'value'}} -> ['parent','child']
 * @param  {Number} index - Must not be set, since it is implicit.
 * @return {String|Number}       The property, which is to be compared by sort.
 */
function recurseObjProp(root, leafs, index) {
  index ? index : index = 0
  var upper = root
  // walk down one level
  lower = upper[leafs[index]]
  // Check if last leaf has been hit by having gone one step too far.
  // If so, return result from last step.
  if (!lower) {
    return upper
  }
  // Else: recurse!
  index++
  // HINT: Bug was here, for not explicitly returning function
  // https://stackoverflow.com/a/17528613/3580261
  return recurseObjProp(lower, leafs, index)
}

/**
 * Multi-sort your array by a set of properties
 * @param {...Array} Arrays to access values in the form of: {parent:{ child: 'value'}} -> ['parent','child']
 * @return {Number} Number - number for sort algorithm
 */
function dynamicMultiSort() {
  var args = Array.prototype.slice.call(arguments); // slight deviation to base

  return function (a, b) {
    var i = 0, result = 0, numberOfProperties = args.length;
    // REVIEW: slightly verbose; maybe no way around because of `.sort`-'s nature
    // Consider: `.forEach()`
    while(result === 0 && i < numberOfProperties) {
      result = dynamicSort(args[i])(a, b);
      i++;
    }
    return result;
  }
}

उदाहरण

कार्य उदाहरण JSBin पर

16
Community 23 मई 2017, 15:18
3
क्यों? यह मूल प्रश्न का उत्तर नहीं है और "लक्ष्य" को केवल People.sort((a,b)=>{ return a.Name.name.localeCompare(b.Name.name) के साथ हल किया जा सकता है || a.Name .surname.localeCompare(b.Name.surname)})
 – 
Tero Tolonen
3 मई 2016, 19:02

एक और विकल्प:

var someArray = [...];

function generateSortFn(prop, reverse) {
    return function (a, b) {
        if (a[prop] < b[prop]) return reverse ? 1 : -1;
        if (a[prop] > b[prop]) return reverse ? -1 : 1;
        return 0;
    };
}

someArray.sort(generateSortFn('name', true));

डिफ़ॉल्ट रूप से आरोही प्रकार।

14
ravshansbox 26 जून 2016, 12:10
1
यदि आवश्यक हो तो एकाधिक क्षेत्रों द्वारा छँटाई के लिए थोड़ा बदला हुआ संस्करण यहाँ है: stackoverflow.com/questions/6913512/…
 – 
ravshansbox
1 पद 2016, 15:37
ऐसा लगता है कि यह अगला हो सकता है: निर्यात फ़ंक्शन जनरेटसॉर्टफ़न (प्रोप: स्ट्रिंग, रिवर्स: बूलियन = झूठा): (... args: कोई भी) => संख्या {वापसी (ए, बी) => {वापसी एक [प्रोप ] <बी [प्रोप]? उलटना ? 1: -1: ए [प्रोप]> बी [प्रोप]? उलटना ? -1: 1: 0; }; }
 – 
Den Kerny
23 मई 2020, 07:29
सहमत हुए, लेकिन कुछ मामलों में मुझे उपयोगिता कार्यों को देखने की जरूरत नहीं है।
 – 
Den Kerny
25 मई 2020, 05:00

एक आसान तरीका:

objs.sort(function(a,b) {
  return b.last_nom.toLowerCase() < a.last_nom.toLowerCase();
});

देखें कि त्रुटियों को रोकने के लिए '.toLowerCase()' आवश्यक है तार की तुलना में।

12
Caio Ladislau 15 जिंदा 2016, 16:32
4
आप एरो फंक्शन का उपयोग कर सकते हैं ताकि कोड थोड़ा और सुरुचिपूर्ण: objs.sort( (a,b) => b.last_nom.toLowerCase() < a.last_nom.toLowerCase() );
 – 
Sertage
24 मई 2017, 18:04
यह उसी कारण से गलत है जैसा समझाया गया है यहाँ .
 – 
Patrick Roberts
18 जुलाई 2018, 12:24
2
एरो फ़ंक्शंस ES5-योग्य नहीं हैं। टनों इंजन अभी भी ES5 तक ही सीमित हैं। मेरे मामले में, जब से मैं ES5 इंजन (मेरी कंपनी द्वारा मजबूर) पर हूं, मुझे ऊपर का उत्तर काफी बेहतर लगता है
 – 
dylanh724
21 जुलाई 2018, 11:50

Ege zcan कोड . के लिए अतिरिक्त विवरण पैराम्स

function dynamicSort(property, desc) {
    if (desc) {
        return function (a, b) {
            return (a[property] > b[property]) ? -1 : (a[property] < b[property]) ? 1 : 0;
        }   
    }
    return function (a, b) {
        return (a[property] < b[property]) ? -1 : (a[property] > b[property]) ? 1 : 0;
    }
}
10
Behnam Shomali 17 सितंबर 2012, 00:22

विनय के विचार के साथ ईजी के गतिशील समाधान का संयोजन, आपको एक अच्छा मजबूत समाधान मिलता है:

Array.prototype.sortBy = function() {
    function _sortByAttr(attr) {
        var sortOrder = 1;
        if (attr[0] == "-") {
            sortOrder = -1;
            attr = attr.substr(1);
        }
        return function(a, b) {
            var result = (a[attr] < b[attr]) ? -1 : (a[attr] > b[attr]) ? 1 : 0;
            return result * sortOrder;
        }
    }
    function _getSortFunc() {
        if (arguments.length == 0) {
            throw "Zero length arguments not allowed for Array.sortBy()";
        }
        var args = arguments;
        return function(a, b) {
            for (var result = 0, i = 0; result == 0 && i < args.length; i++) {
                result = _sortByAttr(args[i])(a, b);
            }
            return result;
        }
    }
    return this.sort(_getSortFunc.apply(null, arguments));
}

उपयोग:

// Utility for printing objects
Array.prototype.print = function(title) {
    console.log("************************************************************************");
    console.log("**** "+title);
    console.log("************************************************************************");
    for (var i = 0; i < this.length; i++) {
        console.log("Name: "+this[i].FirstName, this[i].LastName, "Age: "+this[i].Age);
    }
}

// Setup sample data
var arrObj = [
    {FirstName: "Zach", LastName: "Emergency", Age: 35},
    {FirstName: "Nancy", LastName: "Nurse", Age: 27},
    {FirstName: "Ethel", LastName: "Emergency", Age: 42},
    {FirstName: "Nina", LastName: "Nurse", Age: 48},
    {FirstName: "Anthony", LastName: "Emergency", Age: 44},
    {FirstName: "Nina", LastName: "Nurse", Age: 32},
    {FirstName: "Ed", LastName: "Emergency", Age: 28},
    {FirstName: "Peter", LastName: "Physician", Age: 58},
    {FirstName: "Al", LastName: "Emergency", Age: 51},
    {FirstName: "Ruth", LastName: "Registration", Age: 62},
    {FirstName: "Ed", LastName: "Emergency", Age: 38},
    {FirstName: "Tammy", LastName: "Triage", Age: 29},
    {FirstName: "Alan", LastName: "Emergency", Age: 60},
    {FirstName: "Nina", LastName: "Nurse", Age: 54}
];

//Unit Tests
arrObj.sortBy("LastName").print("LastName Ascending");
arrObj.sortBy("-LastName").print("LastName Descending");
arrObj.sortBy("LastName", "FirstName", "-Age").print("LastName Ascending, FirstName Ascending, Age Descending");
arrObj.sortBy("-FirstName", "Age").print("FirstName Descending, Age Ascending");
arrObj.sortBy("-Age").print("Age Descending");
10
Mike R 23 अप्रैल 2013, 20:07
1
विचार के लिए धन्यवाद! वैसे, कृपया लोगों को ऐरे प्रोटोटाइप को बदलने के लिए प्रोत्साहित न करें (मेरे उदाहरण के अंत में चेतावनी देखें)।
 – 
Ege Özcan
10 मई 2013, 18:51

एक साधारण कार्य जो किसी संपत्ति द्वारा वस्तु की एक सरणी को सॉर्ट करता है

function sortArray(array, property, direction) {
    direction = direction || 1;
    array.sort(function compare(a, b) {
        let comparison = 0;
        if (a[property] > b[property]) {
            comparison = 1 * direction;
        } else if (a[property] < b[property]) {
            comparison = -1 * direction;
        }
        return comparison;
    });
    return array; // Chainable
}

उपयोग:

var objs = [ 
    { first_nom: 'Lazslo', last_nom: 'Jamf'     },
    { first_nom: 'Pig',    last_nom: 'Bodine'   },
    { first_nom: 'Pirate', last_nom: 'Prentice' }
];

sortArray(objs, "last_nom"); // Asc
sortArray(objs, "last_nom", -1); // Desc
11
Francois Girard 28 मई 2018, 22:54
यह समाधान मेरे लिए द्वि-दिशात्मक सॉर्ट करने के लिए पूरी तरह से काम करता है। धन्यवाद
 – 
manjuvreddy
23 मार्च 2020, 20:23

अपने उदाहरण के अनुसार, आपको दो क्षेत्रों (अंतिम नाम, प्रथम नाम) के आधार पर क्रमबद्ध करना होगा, न कि एक। इस प्रकार को एक पंक्ति में बनाने के लिए आप Alasql लाइब्रेरी का उपयोग कर सकते हैं:

var res = alasql('SELECT * FROM ? ORDER BY last_nom, first_nom',[objs]);

इस उदाहरण को jsFiddle पर आज़माएं।

8
agershun 18 पद 2014, 14:09

चेतावनी!
इस समाधान का उपयोग अनुशंसित नहीं है क्योंकि इसका परिणाम क्रमबद्ध सरणी में नहीं होता है। इसे भविष्य के संदर्भ के लिए यहां छोड़ा जा रहा है, क्योंकि यह विचार दुर्लभ नहीं है।

objs.sort(function(a,b){return b.last_nom>a.last_nom})
11
Ben Carp 11 पद 2020, 15:42
2
असल में यह काम नहीं कर रहा था, स्वीकृत उत्तर का उपयोग करना था। यह सही ढंग से छँटाई नहीं कर रहा था।
 – 
madprops
21 फरवरी 2017, 14:15

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

objs.sort(function (a,b) {

var nameA=a.last_nom.toLowerCase(), nameB=b.last_nom.toLowerCase()

if (nameA < nameB)
  return -1;
if (nameA > nameB)
  return 1;
return 0;  //no sorting

})
7
Burak Keceli 14 अगस्त 2013, 14:40
function compare(propName) {
    return function(a,b) {
        if (a[propName] < b[propName])
            return -1;
        if (a[propName] > b[propName])
            return 1;
        return 0;
    };
}

objs.sort(compare("last_nom"));
9
Evgenii 29 अक्टूबर 2015, 16:09

मूल उदाहरण को देखते हुए:

var objs = [ 
    { first_nom: 'Lazslo', last_nom: 'Jamf'     },
    { first_nom: 'Pig',    last_nom: 'Bodine'   },
    { first_nom: 'Pirate', last_nom: 'Prentice' }
];

कई क्षेत्रों के आधार पर छाँटें:

objs.sort(function(left, right) {
    var last_nom_order = left.last_nom.localeCompare(right.last_nom);
    var first_nom_order = left.first_nom.localeCompare(right.first_nom);
    return last_nom_order || first_nom_order;
});

टिप्पणियाँ

  • a.localeCompare(b) सार्वभौमिक रूप से समर्थित है और यदि a<b है तो -1,0,1 लौटाता है ,a==b,a>b क्रमशः।
  • अंतिम पंक्ति में || last_nom को first_nom से अधिक प्राथमिकता देता है।
  • अंकीय क्षेत्रों पर घटाव कार्य करता है: var age_order = left.age - right.age;
  • रिवर्स ऑर्डर के लिए नकारात्मक, return -last_nom_order || -first_nom_order || -age_order;
8
Bob Stein 24 फरवरी 2018, 03:54

यह एक साधारण समस्या है, पता नहीं लोगों के पास इतना जटिल समाधान क्यों है।
एक साधारण सॉर्ट फ़ंक्शन (त्वरित-क्रमबद्ध एल्गोरिथम पर आधारित):

function sortObjectsArray(objectsArray, sortKey)
        {
            // Quick Sort:
            var retVal;

            if (1 < objectsArray.length)
            {
                var pivotIndex = Math.floor((objectsArray.length - 1) / 2);  // middle index
                var pivotItem = objectsArray[pivotIndex];                    // value in the middle index
                var less = [], more = [];

                objectsArray.splice(pivotIndex, 1);                          // remove the item in the pivot position
                objectsArray.forEach(function(value, index, array)
                {
                    value[sortKey] <= pivotItem[sortKey] ?                   // compare the 'sortKey' proiperty
                        less.push(value) :
                        more.push(value) ;
                });

                retVal = sortObjectsArray(less, sortKey).concat([pivotItem], sortObjectsArray(more, sortKey));
            }
            else
            {
                retVal = objectsArray;
            }

            return retVal;
        }

उदाहरण का प्रयोग करें:

var myArr = 
        [
            { val: 'x', idx: 3 },
            { val: 'y', idx: 2 },
            { val: 'z', idx: 5 },
        ];
myArr = sortObjectsArray(myArr, 'idx');
8
Gil Epshtain 19 नवम्बर 2015, 17:27
5
जेएस में त्वरित प्रकार को एक साधारण समाधान कैसे कार्यान्वित कर रहा है? सरल एल्गोरिदम लेकिन एक आसान समाधान नहीं।
 – 
Andrew
24 नवम्बर 2015, 01:46
यह सरल है क्योंकि यह किसी बाहरी पुस्तकालय का उपयोग नहीं करता है और यह वस्तु के प्रोटोटाइप को नहीं बदलता है। मेरी राय में, कोड की लंबाई का कोड की जटिलता पर सीधा प्रभाव नहीं पड़ता है
 – 
Gil Epshtain
24 नवम्बर 2015, 15:02
2
ठीक है, मुझे अलग-अलग शब्दों के साथ प्रयास करने दें: पहिया को फिर से बनाना एक सरल उपाय कैसे है?
 – 
Roberto14
9 पद 2015, 20:36

रामदा का उपयोग करना,

npm ramda इंस्टॉल करें

import R from 'ramda'
var objs = [ 
    { first_nom: 'Lazslo', last_nom: 'Jamf'     },
    { first_nom: 'Pig',    last_nom: 'Bodine'   },
    { first_nom: 'Pirate', last_nom: 'Prentice' }
];
var ascendingSortedObjs = R.sortBy(R.prop('last_nom'), objs)
var descendingSortedObjs = R.reverse(ascendingSortedObjs)
8
Sridhar Sg 5 जुलाई 2017, 10:43

मैंने अभी-अभी Ege zcan के डायनामिक सॉर्ट को ऑब्जेक्ट के अंदर गहराई में जाने के लिए बढ़ाया है। यदि डेटा इस तरह दिखता है:

obj = [
    {
        a: { a: 1, b: 2, c: 3 },
        b: { a: 4, b: 5, c: 6 }
    },
    { 
        a: { a: 3, b: 2, c: 1 },
        b: { a: 6, b: 5, c: 4 }
}];

और यदि आप इसे a.a संपत्ति पर क्रमबद्ध करना चाहते हैं तो मुझे लगता है कि मेरी वृद्धि बहुत अच्छी तरह से मदद करती है। मैं इस तरह की वस्तुओं में नई कार्यक्षमता जोड़ता हूं:

Object.defineProperty(Object.prototype, 'deepVal', {
    enumerable: false,
    writable: true,
    value: function (propertyChain) {
        var levels = propertyChain.split('.');
        parent = this;
        for (var i = 0; i < levels.length; i++) {
            if (!parent[levels[i]])
                return undefined;
            parent = parent[levels[i]];
        }
        return parent;
    }
});

और _dynamicSort के वापसी फ़ंक्शन को बदल दिया:

return function (a,b) {
        var result = ((a.deepVal(property) > b.deepVal(property)) - (a.deepVal(property) < b.deepVal(property)));
        return result * sortOrder;
    }

और अब आप a.a. के अनुसार इस प्रकार क्रमित कर सकते हैं:

obj.sortBy('a.a');

JSFiddle में पूरी स्क्रिप्ट देखें

5
Community 23 मई 2017, 15:03

ये कोशिश करें,

UPTO ES5

//Ascending Sort
items.sort(function (a, b) {
   return a.value - b.value;
});


//Descending Sort
items.sort(function (a, b) {
   return b.value - a.value;
});


IN ES6 & above:

// Ascending sort
items.sort((a, b) => a.value - b.value);

// Descending Sort
 items.sort((a, b) => b.value - a.value);
26
Abhishek 3 मार्च 2020, 11:50
2
सबसे अच्छा और आसान उपाय
 – 
Omar Hasan
16 मार्च 2020, 12:21

आप पुन: प्रयोज्य सॉर्ट फ़ंक्शन का उपयोग कर सकते हैं।

Array.prototype.order = function (prop, methods = {}) {
    if (prop?.constructor == Object) {
        methods = prop;
        prop = null;
    }
    const [orderType_a, orderType_b] = methods.reverse ? [1, -1] : [-1, 1];

    const $ = x => prop
        ? methods.insensitive
            ? String(x[prop]).toLowerCase()
            : x[prop]
        : methods.insensitive
            ? String(x).toLowerCase()
            : x;

    const fn = (a, b) => $(a) < $(b) ? orderType_a : $(b) < $(a) ? orderType_b : 0;
    return this.sort(fn);
};

इसका उपयोग सरणी और ऑब्जेक्ट दोनों को सरणी
में सॉर्ट करने के लिए किया जा सकता है।

let items = [{ x: "Z" }, 3, "1", "0", 2, { x: "a" }, { x: 0 }];
items
    .order("x", { insensitive: 1 })
    // [ { x: 0 }, { x: 'a' }, 3, '1', '0', 2, { x: 'Z' } ]
    .order({ reverse: 1 })
    // [ { x: 0 }, { x: 'a' }, 3, 2, { x: 'Z' }, '1', '0' ]
    .sort(x => typeof x == "string" || typeof x == "number" ? -1 : 0)
    // [ '0', '1', 2, 3, { x: 0 }, { x: 'a' }, { x: 'Z' } ]

पहला (वैकल्पिक) > सरणी में समाहित ऑब्जेक्ट को सॉर्ट करने के लिए।
दूसरा तरीका है > { reverse: any, insensitive: any }

8
Nur 3 अप्रैल 2021, 22:12

आप शॉर्ट कोड क्यों नहीं लिखते?

objs.sort((a, b) => a.last_nom > b.last_nom && 1 || -1)
9
artem 9 अप्रैल 2021, 15:58
क्या होगा यदि मूल्य बराबर हैं? यह देखते हुए कि आप 3 मान वापस कर सकते हैं - 1, -1, 0
 – 
Someone Special
15 अप्रैल 2021, 12:36
तो क्या हुआ? परिणाम वही होगा
 – 
artem
15 अप्रैल 2021, 14:15
1 क्या करता है || -1 मतलब?
 – 
Kaleem Elahi
26 जून 2021, 20:53
अगर मैं सही ढंग से समझूं, तो वह इसे थोड़ा मुखौटा के रूप में इस्तेमाल कर रहा है। अगर a.last_nom > b.last_nom तो 1 ELSE -1. तुलना के आधार पर किसी आइटम को प्रभावी ढंग से ऊपर या नीचे ले जाना।
 – 
Robert Talada
11 नवम्बर 2021, 02:22
कोई बिट मास्क नहीं है, अभिव्यक्ति a>b && 1|| -1 a> b ? 1 : -1 के बराबर है, ऑपरेटर && पहले तार्किक false मान देता है, ऑपरेटर || पहले तार्किक देता है true मूल्य।
 – 
artem
11 नवम्बर 2021, 09:19