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




arrays sorting (20)

छंटनी (अधिक) वस्तुओं के जटिल Arrays

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

टी एल; डॉ

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

मुसीबत

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

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.surname

बाधाओं

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

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

उपाय

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

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

उदाहरण

जेएसबीन पर कामकाजी उदाहरण

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

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


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

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

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

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

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

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 छोड़ दें।


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

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

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


एक और विकल्प:

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

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


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

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

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


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

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

})

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

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

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


मैंने बस गहरे अंदर वस्तुओं को गोता लगाने के लिए एज ओज़केन के गतिशील प्रकार को बढ़ाया। यदि डेटा इस तरह दिखता है:

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

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

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

और अब आप इस तरह से एए सॉर्ट कर सकते हैं:

obj.sortBy('a.a');

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


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

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

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

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

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


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

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)

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

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

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

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"}
*/

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;

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>


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


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







properties