javascript जावास्क्रिप्ट में स्ट्रिंग प्रॉपर्टी वैल्यू द्वारा ऑब्जेक्ट्स की सरणी सॉर्ट करें




arrays sorting (24)

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

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) बारे में पता है, लेकिन यह केवल तारों और संख्याओं पर काम करता प्रतीत होता है। क्या मुझे अपनी ऑब्जेक्ट्स में एक टूस्ट्रिंग विधि जोड़ने की ज़रूरत है?


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

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

ऑपरेटर को इसके विपरीत क्रमबद्ध क्रमबद्ध क्रमबद्ध करने के लिए स्वैप करें।


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

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

जहां fn1 , fn2 , ... क्रमबद्ध फ़ंक्शन हैं जो [-1,0,1] लौटते हैं। इसके परिणामस्वरूप "एफएन 1 द्वारा सॉर्टिंग", "एफएन 2 द्वारा सॉर्टिंग" जो एसक्यूएल में ऑर्डर के बराबर है।

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

सबसे सरल रूप में इस तरह के केवल एक रेखांकित कार्य है:

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

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


एज ओज़कन कोड के लिए अतिरिक्त desc params

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

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

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

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


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

मेरे पास कोड का एक टुकड़ा है जो मेरे लिए काम करता है:

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

अद्यतन: हमेशा काम नहीं कर रहा है, इसलिए यह सही नहीं है :(


Lodash.js ( Underscore.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 shorthand user.age का उपयोग कर सकते हैं जिसे मिलान किया जाना चाहिए। हम उपयोगकर्ता वस्तुओं को नेस्टेड आयु संपत्ति द्वारा सॉर्ट करेंगे। हां, यह नेस्टेड संपत्ति मिलान के लिए अनुमति देता है!

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

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

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

बजाय Chaining का उपयोग करके दोनों को गठबंधन करना चाहते हैं?

const sortedObjs = _.chain(users).sortBy('user.age').reverse().value();

Given the original example:

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

Sort by multiple fields:

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) is universally supported and returns -1,0,1 if a<b , a==b , a>b respectively.
  • || in the last line gives last_nom priority over first_nom .
  • Subtraction works on numeric fields: var age_order = left.age - right.age;
  • Negate to reverse order, return -last_nom_order || -first_nom_order || -age_order;

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

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

JsFiddle पर इस उदाहरण का प्रयास करें।


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

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: 'Pako',              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'));

XPrototype का उपयोग करना: https://github.com/reduardo7/xPrototype/blob/master/README.md#sortbycol1-col2-coln

var o = [ 
  { Name: 'Lazslo', LastName: 'Jamf'     },
  { Name: 'Pig',    LastName: 'Bodine'   },
  { Name: 'Pirate', LastName: 'Prentice' },
  { Name: 'Pag',    LastName: 'Bodine'   }
];


// Original
o.each(function (a, b) { console.log(a, b); });
/*
 0 Object {Name: "Lazslo", LastName: "Jamf"}
 1 Object {Name: "Pig", LastName: "Bodine"}
 2 Object {Name: "Pirate", LastName: "Prentice"}
 3 Object {Name: "Pag", LastName: "Bodine"}
*/


// Sort By LastName ASC, Name ASC
o.sortBy('LastName', 'Name').each(function(a, b) { console.log(a, b); });
/*
 0 Object {Name: "Pag", LastName: "Bodine"}
 1 Object {Name: "Pig", LastName: "Bodine"}
 2 Object {Name: "Lazslo", LastName: "Jamf"}
 3 Object {Name: "Pirate", LastName: "Prentice"}
*/


// Sort by LastName ASC and Name ASC
o.sortBy('LastName'.asc, 'Name'.asc).each(function(a, b) { console.log(a, b); });
/*
 0 Object {Name: "Pag", LastName: "Bodine"}
 1 Object {Name: "Pig", LastName: "Bodine"}
 2 Object {Name: "Lazslo", LastName: "Jamf"}
 3 Object {Name: "Pirate", LastName: "Prentice"}
*/


// Sort by LastName DESC and Name DESC
o.sortBy('LastName'.desc, 'Name'.desc).each(function(a, b) { console.log(a, b); });
/*
 0 Object {Name: "Pirate", LastName: "Prentice"}
 1 Object {Name: "Lazslo", LastName: "Jamf"}
 2 Object {Name: "Pig", LastName: "Bodine"}
 3 Object {Name: "Pag", LastName: "Bodine"}
*/


// Sort by LastName DESC and Name ASC
o.sortBy('LastName'.desc, 'Name'.asc).each(function(a, b) { console.log(a, b); });
/*
 0 Object {Name: "Pirate", LastName: "Prentice"}
 1 Object {Name: "Lazslo", LastName: "Jamf"}
 2 Object {Name: "Pag", LastName: "Bodine"}
 3 Object {Name: "Pig", LastName: "Bodine"}
*/

underscore.js

अंडरस्कोर का उपयोग करें, इसकी छोटी और भयानक ...

sortBy_.sortBy (सूची, पुनरावर्तक, [संदर्भ]) सूची की एक क्रमबद्ध प्रतिलिपि देता है, जो इटरेटर के माध्यम से प्रत्येक मान को चलाने के परिणामों द्वारा आरोही क्रम में रैंक किया जाता है। इटरेटर (उदाहरण के लिए लंबाई) द्वारा क्रमबद्ध करने के लिए संपत्ति का स्ट्रिंग नाम भी हो सकता है।

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

var sortedObjs = _.sortBy( objs, 'first_nom' );

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

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

})

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

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

I came into problem of sorting array of objects, with changing priority of values, basically I want to sort array of peoples by their Age, and then by surname - or just by surname, name. I think that this is most simple solution compared to another answers.

it' is used by calling sortPeoples(['array', 'of', 'properties'], reverse=false)

///////////////////////example array of peoples ///////////////////////

var peoples = [
    {name: "Zach", surname: "Emergency", age: 1},
    {name: "Nancy", surname: "Nurse", age: 1},
    {name: "Ethel", surname: "Emergency", age: 1},
    {name: "Nina", surname: "Nurse", age: 42},
    {name: "Anthony", surname: "Emergency", age: 42},
    {name: "Nina", surname: "Nurse", age: 32},
    {name: "Ed", surname: "Emergency", age: 28},
    {name: "Peter", surname: "Physician", age: 58},
    {name: "Al", surname: "Emergency", age: 58},
    {name: "Ruth", surname: "Registration", age: 62},
    {name: "Ed", surname: "Emergency", age: 38},
    {name: "Tammy", surname: "Triage", age: 29},
    {name: "Alan", surname: "Emergency", age: 60},
    {name: "Nina", surname: "Nurse", age: 58}
];



//////////////////////// Sorting function /////////////////////
function sortPeoples(propertyArr, reverse) {
        function compare(a,b) {
            var i=0;
            while (propertyArr[i]) {
                if (a[propertyArr[i]] < b[propertyArr[i]])  return -1;
                if (a[propertyArr[i]] > b[propertyArr[i]])  return 1;
                i++;
            }
            return 0;
            }
        peoples.sort(compare);
        if (reverse){
            peoples.reverse();
        }
    };

////////////////end of sorting method///////////////
function printPeoples(){
  $('#output').html('');
peoples.forEach( function(person){
 $('#output').append(person.surname+" "+person.name+" "+person.age+"<br>");
} )
}
<head>
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
</head>
  <html>
  <body>
<button onclick="sortPeoples(['surname']); printPeoples()">sort by ONLY by surname ASC results in mess with same name cases</button><br>
<button onclick="sortPeoples(['surname', 'name'], true); printPeoples()">sort by surname then name DESC</button><br>
<button onclick="sortPeoples(['age']); printPeoples()">sort by AGE ASC. Same issue as in first case</button><br>
<button onclick="sortPeoples(['age', 'surname']); printPeoples()">sort by AGE and Surname ASC. Adding second field fixed it.</button><br>
        
    <div id="output"></div>
    </body>
  </html>


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

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

अद्यतन: अब मूल सरणी को संशोधित नहीं करता है।


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

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

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

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}     
 */
function 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.
  var 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.
  var moveLarger = reverse ? -1 : 1;

  /**
   * @param  {*} a
   * @param  {*} b
   * @return {Number}
   */
  return function(a, b) {
    if (a[key] < b[key]) {
      return moveSmaller;
    }
    if (a[key] > b[key]) {
      return moveLarger;
    }
    return 0;
  };

}

आप गतिशील सॉर्ट फ़ंक्शन भी बना सकते हैं जो ऑब्जेक्ट्स को उनके मूल्य से टाइप करता है जो आप पास करते हैं:

function dynamicSort(property) {
    var sortOrder = 1;
    if(property[0] === "-") {
        sortOrder = -1;
        property = property.substr(1);
    }
    return function (a,b) {
        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"));

प्रोटोटाइप में इसे जोड़ना

(कार्यान्वयन जो नीचे है, माइक आर के answer से प्रेरित है)

मैं एक देशी ऑब्जेक्ट प्रोटोटाइप को बदलने की सिफारिश नहीं करता लेकिन केवल एक उदाहरण देने के लिए ताकि आप इसे अपने स्वयं के ऑब्जेक्ट्स पर कार्यान्वित कर सकें (इसके समर्थन वाले वातावरण के लिए, आप Object.defineProperty भी उपयोग कर सकते हैं जैसा कि कम से कम अगले खंड में दिखाया गया है, जो कम से कम पिछले भाग में वर्णित अनुसार, गणित होने का नकारात्मक दुष्प्रभाव नहीं है)

प्रोटोटाइप कार्यान्वयन निम्न की तरह कुछ होगा ( यहां एक कामकाजी उदाहरण है ):

//Don't just copy-paste this code. You will break the "for-in" loops
!function() {
    function _dynamicSortMultiple(attr) {
       /* dynamicSortMultiple function body comes here */
    }
    function _dynamicSort(property) {
        /* dynamicSort function body comes here */
    }
    Array.prototype.sortBy = function() {
        return this.sort(_dynamicSortMultiple.apply(null, arguments));
    }
}();

प्रोटोटाइप में इसे जोड़ने का "ठीक" तरीका

यदि आप IE v9.0 को लक्षित कर रहे हैं और ऊपर, जैसा कि मैंने पहले उल्लेख किया था, इस तरह Object.defineProperty उपयोग करें ( काम कर रहे उदाहरण ):

//Won't work below IE9, but totally safe otherwise
!function() {
    function _dynamicSortMultiple(attr) {
       /* dynamicSortMultiple function body comes here */
    }
    function _dynamicSort(property) {
        /* dynamicSort function body comes here */
    }
    Object.defineProperty(Array.prototype, "sortBy", {
        enumerable: false,
        writable: true,
        value: function() {
            return this.sort(_dynamicSortMultiple.apply(null, arguments));
        }
    });
}();

बाइंड ऑपरेटर आने तक यह एक स्वीकार्य समझौता हो सकता है।

उन सभी प्रोटोटाइप मज़ा इस सक्षम बनाता है:

People.sortBy("Name", "-Surname");

आपको इसे पढ़ना चाहिए

यदि आप प्रत्यक्ष प्रोटोटाइप एक्सेस विधि का उपयोग करते हैं (ऑब्जेक्ट.डेफिनप्रोपर्टी ठीक है) और अन्य कोड hasOwnProperty जांच नहीं करता है, बिल्ली के बच्चे मर जाते हैं! ठीक है, ईमानदार होने के लिए, वास्तव में किसी भी बिल्ली के बच्चे को कोई नुकसान नहीं होता है, लेकिन शायद चीजें टूट जाएंगी और आपकी टीम में हर दूसरे डेवलपर आपको नफरत करेगा:

आखिरी "Sortbyy" देखें? हाँ। अछा नहीं लगता। ऑब्जेक्ट.डेफिनप्रोपर्टी का प्रयोग करें जहां आप कर सकते हैं, और अन्यथा अकेले Array.prototype छोड़ दें।


अपने स्वयं के तुलनात्मक कार्य को लिखना काफी आसान है:

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

या इनलाइन (सी / ओ मार्को डेमायो):

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

एक और विकल्प:

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

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


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

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)

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

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

// Sort Array of Objects

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

// Property to Sort By
var args = "last_nom";

// Function to Sort the Data by given Property
function sortByProperty(property) {
    return function (a, b) {
        var sortStatus = 0,
            aProp = a[property].toLowerCase(),
            bProp = b[property].toLowerCase();
        if (aProp < bProp) {
            sortStatus = -1;
        } else if (aProp > bProp) {
            sortStatus = 1;
        }
        return sortStatus;
    };
}

// Implementation
var sortedArray = booksArray.sort(sortByProperty(args));

console.log("sortedArray: " + JSON.stringify(sortedArray) );

Console log output:

"sortedArray: 
[{"first_nom":"Pig","last_nom":"Bodine"},
{"first_nom":"Lazslo","last_nom":"Jamf"},
{"first_nom":"Pirate","last_nom":"Prentice"}]"

इस स्रोत के आधार पर अनुकूलित: http://www.levihackwith.com/code-snippet-how-to-sort-an-array-of-json-objects-by-property/





properties