javascript - जावास्क्रिप्ट ऑब्जेक्ट्स की एक सरणी को सॉर्ट करना




arrays sorting (16)

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

नोट : by यह संस्करण स्थिर है । यह अगली जंजीर प्रकार के दौरान पहली तरह के क्रम को सुरक्षित रखता है।

मैंने इसमें जोड़ा पैरामीटर जोड़ा है। इसे लेखक द्वारा अनुशंसित ES6 मानकों और "नए" अच्छे हिस्सों में भी परिवर्तित कर दिया गया।

आप आरोही के साथ-साथ अवरोही और चेन सॉर्ट को कई गुणों से सॉर्ट कर सकते हैं।

const by = function (name, minor, isAscending=true) {
    const reverseMutliplier = isAscending ? 1 : -1;
    return function (o, p) {
        let a, b;
        let result;
        if (o && p && typeof o === "object" && typeof p === "object") {
            a = o[name];
            b = p[name];
            if (a === b) {
                return typeof minor === 'function' ? minor(o, p) : 0;
            }
            if (typeof a === typeof b) {
                result = a < b ? -1 : 1;
            } else {
                result = typeof a < typeof b ? -1 : 1;
            }
            return result * reverseMutliplier;
        } else {
            throw {
                name: "Error",
                message: "Expected an object when sorting by " + name
            };
        }
    };
};

let s = [
    {first: 'Joe',   last: 'Besser'},
    {first: 'Moe',   last: 'Howard'},
    {first: 'Joe',   last: 'DeRita'},
    {first: 'Shemp', last: 'Howard'},
    {first: 'Larry', last: 'Fine'},
    {first: 'Curly', last: 'Howard'}
];

// Sort by: first ascending, last ascending
s.sort(by("first", by("last")));    
console.log("Sort by: first ascending, last ascending: ", s);     // "[
//     {"first":"Curly","last":"Howard"},
//     {"first":"Joe","last":"Besser"},     <======
//     {"first":"Joe","last":"DeRita"},     <======
//     {"first":"Larry","last":"Fine"},
//     {"first":"Moe","last":"Howard"},
//     {"first":"Shemp","last":"Howard"}
// ]

// Sort by: first ascending, last descending
s.sort(by("first", by("last", 0, false)));  
console.log("sort by: first ascending, last descending: ", s);    // "[
//     {"first":"Curly","last":"Howard"},
//     {"first":"Joe","last":"DeRita"},     <========
//     {"first":"Joe","last":"Besser"},     <========
//     {"first":"Larry","last":"Fine"},
//     {"first":"Moe","last":"Howard"},
//     {"first":"Shemp","last":"Howard"}
// ]

मैंने अजाक्स का उपयोग करके निम्नलिखित ऑब्जेक्ट्स को पढ़ा और उन्हें एक सरणी में संग्रहीत किया:

var homes = [
    {
        "h_id": "3",
        "city": "Dallas",
        "state": "TX",
        "zip": "75201",
        "price": "162500"
    }, {
        "h_id": "4",
        "city": "Bevery Hills",
        "state": "CA",
        "zip": "90210",
        "price": "319250"
    }, {
        "h_id": "5",
        "city": "New York",
        "state": "NY",
        "zip": "00010",
        "price": "962500"
    }
];

मैं केवल जावास्क्रिप्ट का उपयोग करके price संपत्ति द्वारा आरोही या अवरोही क्रम में वस्तुओं को सॉर्ट करने के लिए फ़ंक्शन कैसे बना सकता हूं?


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

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

आप कॉलबैक फ़ंक्शन के साथ जावास्क्रिप्ट sort विधि का उपयोग कर सकते हैं:

function compareASC(homeA, homeB)
{
    return parseFloat(homeA.price) - parseFloat(homeB.price);
}

function compareDESC(homeA, homeB)
{
    return parseFloat(homeB.price) - parseFloat(homeA.price);
}

// Sort ASC
homes.sort(compareASC);

// Sort DESC
homes.sort(compareDESC);

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

function desc(a, b) {
 return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
}

function asc(a, b) {
  return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
}

फिर आप इसे किसी ऑब्जेक्ट प्रॉपर्टी पर लागू कर सकते हैं:

 data.sort((a, b) => desc(parseFloat(a.price), parseFloat(b.price)));

let data = [
    {label: "one", value:10},
    {label: "two", value:5},
    {label: "three", value:1},
];

// sort functions
function desc(a, b) {
 return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
}

function asc(a, b) {
 return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
}

// DESC
data.sort((a, b) => desc(a.value, b.value));

document.body.insertAdjacentHTML(
 'beforeend', 
 '<strong>DESCending sorted</strong><pre>' + JSON.stringify(data) +'</pre>'
);

// ASC
data.sort((a, b) => asc(a.value, b.value));

document.body.insertAdjacentHTML(
 'beforeend', 
 '<strong>ASCending sorted</strong><pre>' + JSON.stringify(data) +'</pre>'
);


एकाधिक सरणी ऑब्जेक्ट फ़ील्ड पर सॉर्ट करने के लिए। ["a","b","c"] जैसे arrprop सरणी में अपना फ़ील्ड नाम दर्ज करें ["a","b","c"] फिर दूसरे पैरामीटर arrsource वास्तविक स्रोत में पास करें arrsource हम सॉर्ट करना चाहते हैं।

function SortArrayobject(arrprop,arrsource){
arrprop.forEach(function(i){
arrsource.sort(function(a,b){
return ((a[i] < b[i]) ? -1 : ((a[i] > b[i]) ? 1 : 0));
});
});
return arrsource;
}

किसी को किसी की आवश्यकता होने पर स्ट्रिंग सॉर्टिंग के लिए,

var dataArr = {  

    "hello": [{
    "id": 114,
    "keyword": "zzzzzz",
    "region": "Sri Lanka",
    "supportGroup": "administrators",
    "category": "Category2"
}, {
    "id": 115,
    "keyword": "aaaaa",
    "region": "Japan",
    "supportGroup": "developers",
    "category": "Category2"
}]

};
var sortArray = dataArr['hello'];
sortArray.sort(function(a,b) {
    if ( a.region < b.region )
        return -1;
    if ( a.region > b.region )
        return 1;
    return 0;
} );

घरों को आरोही क्रम में कीमतों से क्रमबद्ध करें:

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

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

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

कुछ दस्तावेज here पाए जा सकते here


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

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

सॉर्टिंग फ़ंक्शन बनाना

var sortBy = (function () {
  var toString = Object.prototype.toString,
      // default parser function
      parse = function (x) { return x; },
      // gets the item to be sorted
      getItem = function (x) {
        var isObject = x != null && typeof x === "object";
        var isProp = isObject && this.prop in x;
        return this.parser(isProp ? x[this.prop] : x);
      };

  /**
   * Sorts an array of elements.
   *
   * @param  {Array} array: the collection to sort
   * @param  {Object} cfg: the configuration options
   * @property {String}   cfg.prop: property name (if it is an Array of objects)
   * @property {Boolean}  cfg.desc: determines whether the sort is descending
   * @property {Function} cfg.parser: function to parse the items to expected type
   * @return {Array}
   */
  return function sortby (array, cfg) {
    if (!(array instanceof Array && array.length)) return [];
    if (toString.call(cfg) !== "[object Object]") cfg = {};
    if (typeof cfg.parser !== "function") cfg.parser = parse;
    cfg.desc = !!cfg.desc ? -1 : 1;
    return array.sort(function (a, b) {
      a = getItem.call(cfg, a);
      b = getItem.call(cfg, b);
      return cfg.desc * (a < b ? -1 : +(a > b));
    });
  };

}());

अपरिवर्तित डेटा सेट करना

var data = [
  {date: "2011-11-14T16:30:43Z", quantity: 2, total: 90,  tip: 0,   type: "tab"},
  {date: "2011-11-14T17:22:59Z", quantity: 2, total: 90,  tip: 0,   type: "Tab"},
  {date: "2011-11-14T16:28:54Z", quantity: 1, total: 300, tip: 200, type: "visa"},
  {date: "2011-11-14T16:53:41Z", quantity: 2, total: 90,  tip: 0,   type: "tab"},
  {date: "2011-11-14T16:48:46Z", quantity: 2, total: 90,  tip: 0,   type: "tab"},
  {date: "2011-11-14T17:25:45Z", quantity: 2, total: 200, tip: 0,   type: "cash"},
  {date: "2011-11-31T17:29:52Z", quantity: 1, total: 200, tip: 100, type: "Visa"},
  {date: "2011-11-14T16:58:03Z", quantity: 2, total: 90,  tip: 0,   type: "tab"},
  {date: "2011-11-14T16:20:19Z", quantity: 2, total: 190, tip: 100, type: "tab"},
  {date: "2011-11-01T16:17:54Z", quantity: 2, total: 190, tip: 100, type: "tab"},
  {date: "2011-11-14T17:07:21Z", quantity: 2, total: 90,  tip: 0,   type: "tab"},
  {date: "2011-11-14T16:54:06Z", quantity: 1, total: 100, tip: 0,   type: "Cash"}
];

उसका इस्तेमाल कर रहे हैं

String रूप में "date" द्वारा सरणी व्यवस्थित करें

// sort by @date (ascending)
sortBy(data, { prop: "date" });

// expected: first element
// { date: "2011-11-01T16:17:54Z", quantity: 2, total: 190, tip: 100, type: "tab" }

// expected: last element
// { date: "2011-11-31T17:29:52Z", quantity: 1, total: 200, tip: 100, type: "Visa"}

यदि आप केस संवेदनशील को अनदेखा करना चाहते हैं, तो parser कॉलबैक सेट करें:

// sort by @type (ascending) IGNORING case-sensitive
sortBy(data, {
    prop: "type",
    parser: (t) => t.toUpperCase()
});

// expected: first element
// { date: "2011-11-14T16:54:06Z", quantity: 1, total: 100, tip: 0, type: "Cash" }

// expected: last element
// { date: "2011-11-31T17:29:52Z", quantity: 1, total: 200, tip: 100, type: "Visa" }

यदि आप "date" फ़ील्ड को Date प्रकार के रूप में रूपांतरित करना चाहते हैं:

// sort by @date (descending) AS Date object
sortBy(data, {
    prop: "date",
    desc: true,
    parser: (d) => new Date(d)
});

// expected: first element
// { date: "2011-11-31T17:29:52Z", quantity: 1, total: 200, tip: 100, type: "Visa"}

// expected: last element
// { date: "2011-11-01T16:17:54Z", quantity: 2, total: 190, tip: 100, type: "tab" }

यहां आप कोड के साथ खेल सकते हैं: jsbin.com/lesebi

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


यदि आप Underscore.js उपयोग Underscore.js , तो कृपया प्रयास करें:

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

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

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

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

var ascending = homes.sort((a, b) => Number(a.price) - Number(b.price));
var descending = homes.sort((a, b) => Number(b.price) - Number(a.price));

यहां एक वर्किंग कोड स्निपेट है:

var homes = [{
  "h_id": "3",
  "city": "Dallas",
  "state": "TX",
  "zip": "75201",
  "price": "162500"
}, {
  "h_id": "4",
  "city": "Bevery Hills",
  "state": "CA",
  "zip": "90210",
  "price": "319250"
}, {
  "h_id": "5",
  "city": "New York",
  "state": "NY",
  "zip": "00010",
  "price": "962500"
}];

var ascending = homes.sort((a, b) => Number(a.price) - Number(b.price));
var descending = homes.sort((a, b) => Number(b.price) - Number(a.price));

console.log("ascending", ascending);
console.log("descending", descending);



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

var homes = [
    {
        "h_id": "3",
        "city": "Dallas",
        "state": "TX",
        "zip": "75201",
        "price": "162500"
    }, {
        "h_id": "4",
        "city": "Bevery Hills",
        "state": "CA",
        "zip": "90210",
        "price": "319250"
    }, {
        "h_id": "5",
        "city": "New York",
        "state": "NY",
        "zip": "00010",
        "price": "962500"
    }
];

console.log("To sort descending/highest first, use operator '<'");

homes.sort(function(a,b) { return a.price.valueOf() < b.price.valueOf();});

console.log(homes);

console.log("To sort ascending/lowest first, use operator '>'");

homes.sort(function(a,b) { return a.price.valueOf() > b.price.valueOf();});

console.log(homes);


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

var sort_by = function(field, reverse, primer){

   var key = primer ? 
       function(x) {return primer(x[field])} : 
       function(x) {return x[field]};

   reverse = !reverse ? 1 : -1;

   return function (a, b) {
       return a = key(a), b = key(b), reverse * ((a > b) - (b > a));
     } 
}

अब आप इच्छानुसार किसी भी क्षेत्र द्वारा क्रमबद्ध कर सकते हैं ...

var homes = [{

   "h_id": "3",
   "city": "Dallas",
   "state": "TX",
   "zip": "75201",
   "price": "162500"

}, {

   "h_id": "4",
   "city": "Bevery Hills",
   "state": "CA",
   "zip": "90210",
   "price": "319250"

}, {

   "h_id": "5",
   "city": "New York",
   "state": "NY",
   "zip": "00010",
   "price": "962500"

}];

// Sort by price high to low
homes.sort(sort_by('price', true, parseInt));

// Sort by city, case-insensitive, A-Z
homes.sort(sort_by('city', false, function(a){return a.toUpperCase()}));

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

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

function sorterAscending(a,b) {
    return a-b;
}

function sorterDescending(a,b) {
    return b-a;
}

function sorterPriceAsc(a,b) {
    return parseInt(a['price']) - parseInt(b['price']);
}

function sorterPriceDes(a,b) {
    return parseInt(b['price']) - parseInt(b['price']);
}

क्रमबद्ध संख्याएं (वर्णानुक्रम और आरोही):

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.sort();

क्रमबद्ध संख्याएं (वर्णानुक्रम और अवरोही):

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.sort();
fruits.reverse();

क्रमबद्ध संख्याएं (संख्यात्मक रूप से और आरोही):

var points = [40,100,1,5,25,10];
points.sort(sorterAscending());

क्रमबद्ध संख्याएं (संख्यात्मक रूप से और अवरोही):

var points = [40,100,1,5,25,10];
points.sort(sorterDescending());

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

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

हालांकि यह केवल एक सरणी को सॉर्ट करने के लिए एक ओवरकिल है, यह प्रोटोटाइप फ़ंक्शन किसी भी कुंजी द्वारा, जावास्क्रिप्ट सरणी को आरोही या अवरोही क्रम में, नेस्टेड कुंजियों सहित , dot सिंटैक्स का उपयोग करके सॉर्ट करने की अनुमति देता है।

(function(){
    var keyPaths = [];

    var saveKeyPath = function(path) {
        keyPaths.push({
            sign: (path[0] === '+' || path[0] === '-')? parseInt(path.shift()+1) : 1,
            path: path
        });
    };

    var valueOf = function(object, path) {
        var ptr = object;
        for (var i=0,l=path.length; i<l; i++) ptr = ptr[path[i]];
        return ptr;
    };

    var comparer = function(a, b) {
        for (var i = 0, l = keyPaths.length; i < l; i++) {
            aVal = valueOf(a, keyPaths[i].path);
            bVal = valueOf(b, keyPaths[i].path);
            if (aVal > bVal) return keyPaths[i].sign;
            if (aVal < bVal) return -keyPaths[i].sign;
        }
        return 0;
    };

    Array.prototype.sortBy = function() {
        keyPaths = [];
        for (var i=0,l=arguments.length; i<l; i++) {
            switch (typeof(arguments[i])) {
                case "object": saveKeyPath(arguments[i]); break;
                case "string": saveKeyPath(arguments[i].match(/[+-]|[^.]+/g)); break;
            }
        }
        return this.sort(comparer);
    };    
})();

उपयोग:

var data = [
    { name: { first: 'Josh', last: 'Jones' }, age: 30 },
    { name: { first: 'Carlos', last: 'Jacques' }, age: 19 },
    { name: { first: 'Carlos', last: 'Dante' }, age: 23 },
    { name: { first: 'Tim', last: 'Marley' }, age: 9 },
    { name: { first: 'Courtney', last: 'Smith' }, age: 27 },
    { name: { first: 'Bob', last: 'Smith' }, age: 30 }
]

data.sortBy('age'); // "Tim Marley(9)", "Carlos Jacques(19)", "Carlos Dante(23)", "Courtney Smith(27)", "Josh Jones(30)", "Bob Smith(30)"

डॉट-सिंटैक्स या सरणी-सिंटैक्स के साथ नेस्टेड गुणों द्वारा छंटनी:

data.sortBy('name.first'); // "Bob Smith(30)", "Carlos Dante(23)", "Carlos Jacques(19)", "Courtney Smith(27)", "Josh Jones(30)", "Tim Marley(9)"
data.sortBy(['name', 'first']); // "Bob Smith(30)", "Carlos Dante(23)", "Carlos Jacques(19)", "Courtney Smith(27)", "Josh Jones(30)", "Tim Marley(9)"

एकाधिक कुंजी द्वारा छंटनी:

data.sortBy('name.first', 'age'); // "Bob Smith(30)", "Carlos Jacques(19)", "Carlos Dante(23)", "Courtney Smith(27)", "Josh Jones(30)", "Tim Marley(9)"
data.sortBy('name.first', '-age'); // "Bob Smith(30)", "Carlos Dante(23)", "Carlos Jacques(19)", "Courtney Smith(27)", "Josh Jones(30)", "Tim Marley(9)"

आप रेपो फोर्क कर सकते हैं: https://github.com/eneko/Array.sortBy


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

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

घटते क्रम में

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

आरोही क्रम

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





sorting