javascript - जावास्क्रिप्ट में एकाधिक फ़ील्ड वैल्यू के साथ ऑब्जेक्ट की सरणी कैसे सॉर्ट करें




sorting (4)

मुझे गुणों में से किसी एक पर आधारित वस्तुओं के सरणी सॉर्ट करने के लिए एक शानदार विधि मिली:

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

उस फ़ंक्शन का उपयोग करके एक ही तरह के लिए पूरी तरह से कार्य किया जाता है (सभी ब्राउज़रों पर), और यहां तक ​​कि एक तरह से एक और प्रकार के बजाय Google Chrome का उपयोग करते हुए! ऑब्जेक्ट्स के सरणियों के लिए ईगे ओज़कैन की महान प्रकार की नियमित है

function dynamicSort(property) { 
    return function (a,b) {
        return (a[property] < b[property]) ? -1 : (a[property] > b[property]) ? 1 : 0;
    }
}

"डेटा" नामक सरणी का उपयोग करना (निश्चित तौर पर, मेरे सरणी में कई ऑब्जेक्ट जोड़े हैं) ...

var Data = [{Category: "Business", Value: "ABC"},{Category:"Personal", Value:"XYZ"}];

मैं एक उचित प्रकार प्राप्त कर सकता हूं जहां ऑर्डर प्रत्येक वर्ग के भीतर सभी मानों के रूप में सूचीबद्ध है ...

Data.sort(dynamicSort("Value"));
Data.sort(dynamicSort("Category"));

Value पर पहले सॉर्टिंग करके और फिर Category , मेरी सरणी क्रमबद्ध क्रम में सभी मानों को पहले सूचीबद्ध सभी बिजनेस-बेस मानों के साथ रखती है और फिर सभी व्यक्तिगत-आधारित मान उत्तम! सिवाय क्रोम में जहां डेटा श्रेणी के अनुसार ठीक से सॉर्ट किया गया है, लेकिन प्रत्येक श्रेणी के भीतर मानों का क्रम यादृच्छिक लगता है।

क्या किसी को एक तरह से एक तरह से करने का बेहतर तरीका पता है जो क्रोम में भी काम करेगा?


मैंने उस गतिशील सोर्ट फ़ंक्शन के बहु-पैरामीटर संस्करण बनाया है:

function dynamicSort(property) { 
    return function (obj1,obj2) {
        return obj1[property] > obj2[property] ? 1
            : obj1[property] < obj2[property] ? -1 : 0;
    }
}

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

मैंने इस प्रकार एक सरणी बनाई है:

var arr = [
    {a:"a",b:"a",c:"a"},
    {a:"b",b:"a",c:"b"},
    {a:"b",b:"a",c:"a"},
    {a:"b",b:"a",c:"b"},
    {a:"b",b:"b",c:"a"},
    {a:"b",b:"b",c:"b"},
    {a:"b",b:"b",c:"a"},
    {a:"b",b:"b",c:"b"},
    {a:"b",b:"b",c:"a"},
    {a:"b",b:"b",c:"b"},
    {a:"b",b:"b",c:"a"},
    {a:"c",b:"b",c:"b"},
    {a:"c",b:"c",c:"a"}
];

और जब मैंने किया,

arr.sort(dynamicSortMultiple("c","b","a"));

और यहां एक उदाहरण है: http://jsfiddle.net/ZXedp/


आप तब भी देख सकते हैं जैसे जे.जे.: https://github.com/Teun/thenBy.js

यह आपको मानक Array.sort का उपयोग करने की अनुमति देता है, लेकिन पहले से ()। तब ()। तब () शैली।


मैं अब यह पोस्ट काफी पुरानी है, वैसे भी आज मुझे इसे मिला और ईगे ओज़कैन का हवाला देते हुए, मैंने किसी भी रुचि के लिए डीईएससी-एएससी एसक्यूएल-जैसी कार्यक्षमता को लागू करने के अपने उत्कृष्ट समाधान में सुधार ( http://jsfiddle.net/ZXedp/65/ ):

function dynamicSortMultiple() {
    var props=[];
    /*Let's separate property name from ascendant or descendant keyword*/
    for(var i=0; i < arguments.length; i++){
        var splittedArg=arguments[i].split(/ +/);
        props[props.length]=[splittedArg[0], (splittedArg[1] ? splittedArg[1].toUpperCase() : "ASC")];
    }
    return function (obj1, obj2) {
        var i = 0, result = 0, numberOfProperties = props.length ;
        /*Cycle on values until find a difference!*/
        while(result === 0 && i < numberOfProperties) {
            result = dynamicSort(props[i][0], props[i][1])(obj1, obj2);
            i++;
        }
        return result;
    }
}

/*Base function returning -1,1,0 for custom sorting*/
function dynamicSort(property, isAscDesc) { 
    return function (obj1,obj2) {
        if(isAscDesc==="DESC"){
            return ((obj1[property] > obj2[property]) ? (-1) : ((obj1[property] < obj2[property]) ? (1) : (0)));
        }
        /*else, if isAscDesc==="ASC"*/
        return ((obj1[property] > obj2[property]) ? (1) : ((obj1[property] < obj2[property]) ? (-1) : (0)));
    }
}

फ़ंक्शन को इस तरह से कॉल करें:

arr.sort(dynamicSortMultiple("c DESC","b Asc","a"));

एक जावास्क्रिप्ट बहु-मानदंड सॉर्ट (या मल्टी-पैरामीटर सॉर्ट) का सबसे आसान तरीका है, .sort का उपयोग .sort , एक साथ कई पैरामीटर को एक साथ जोड़ना और दो डंक की तुलना करना।

उदाहरण के लिए:

data.sort(function (a, b) {

  var aConcat = a["property1"] + a["property2"];
  var bConcat = b["property1"] + b["property2"];

  if (aConcat > bConcat) {
    return 1;
  } else if (aConcat < bConcat) {
    return -1;
  } else {
    return 0;
  }

});

मैंने यहां एक जेस्फिल्ड स्क्रिप्ट शामिल किया है: http://jsfiddle.net/oahxg4u3/6/






sorting