දේපල අගයන් අනුව වස්තු සමූහයක් වර්ග කිරීම

මම පහත සඳහන් වස්තූන් AJAX භාවිතා කර ඒවා අරාවක ගබඩා කර ඇත:

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දේපල අනුව වස්තූන් නඟින්න හෝ බැසීමේ පිළිවෙලට වර්ග කිරීම සඳහා ශ්‍රිතයක් නිර්මාණය කරන්නේ කෙසේද ?

නිවාස අනුපිළිවෙලින් මිල අනුව වර්ග කරන්න:

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

හෝ ES6 අනුවාදයෙන් පසු:

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

සමහර ලියකියවිලි මෙහි සොයාගත හැකිය .

අවරෝහණ අනුපිළිවෙල සඳහා, ඔබට භාවිතා කළ හැකිය

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

මෙන්න වඩාත් නම්‍යශීලී අනුවාදයක් වන අතර එමඟින් නැවත භාවිතා කළ හැකි වර්ග කිරීමේ කාර්යයන් නිර්මාණය කිරීමට සහ ඕනෑම ක්ෂේත්‍රයක් අනුව වර්ග කිරීමට ඔබට ඉඩ සලසයි.

const sort_by = (field, reverse, primer) => {

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


//Now you can sort by any field at will...

const 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
console.log(homes.sort(sort_by('price', true, parseInt)));

// Sort by city, case-insensitive, A-Z
console.log(homes.sort(sort_by('city', false, (a) =>  a.toUpperCase()
)));

එය වර්ග කිරීම සඳහා ඔබ තර්ක දෙකක් ගෙන සංසන්දනාත්මක ශ්‍රිතයක් නිර්මාණය කළ යුතුය. ඉන්පසු එම සංසන්දනාත්මක ශ්‍රිතය සමඟ වර්ග කිරීමේ ශ්‍රිතය පහත පරිදි අමතන්න:

// a and b are object elements of your array
function mycomparator(a,b) {
  return parseInt(a.price, 10) - parseInt(b.price, 10);
}
homes.sort(mycomparator);

ඔබට ආරෝහණ වර්ග කිරීමට අවශ්‍ය නම් us ණ ලකුණෙහි එක් එක් පැත්තේ ප්‍රකාශන මාරු කරන්න.

යමෙකුට අවශ්‍ය වූ විට නූල් වර්ග කිරීම සඳහා,

const dataArr = {

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

};
const sortArray = dataArr['hello'];

console.log(sortArray.sort((a, b) => {
  if (a.region < b.region)
    return -1;
  if (a.region > b.region)
    return 1;
  return 0;
}));

ඔබට 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"
}];

homes.sort((a, b) => Number(a.price) - Number(b.price));
console.log("ascending", homes);

homes.sort((a, b) => Number(b.price) - Number(a.price));
console.log("descending", homes);

ඔබට එය ජාවාස්ක්‍රිප්ට් හි වර්ග කිරීමට අවශ්‍යයි නේද? ඔබට අවශ්‍ය වන්නේ sort()ශ්‍රිතයයි . මෙම අවස්ථාවේදී ඔබට සංසන්දනාත්මක ශ්‍රිතයක් ලිවීමට අවශ්‍ය වන අතර එය සම්මත කළ යුතුය sort(), එබැවින් මෙවැනි දෙයක්:

function comparator(a, b) {
    return parseInt(a["price"], 10) - parseInt(b["price"], 10);
}

var json = { "homes": [ /* your previous data */ ] };
console.log(json["homes"].sort(comparator));

ඔබේ සංසන්දකයා අරාව තුළ ඇති එක් එක් කැදැලි හැෂ් එකක් ගෙන "මිල" ක්ෂේත්‍රය පරීක්ෂා කිරීමෙන් වඩා ඉහළ කුමන එකක් දැයි තීරණය කරයි.

මම නිර්දේශ කරන්නේ GitHub: Array sortBy - ෂ්වාට්සියානු පරිණාමනය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"}
];

එය භාවිතා කිරීම

විසින්, අරාව පිළිවෙලට "date"ලෙසString

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

ඔහුගේ ප්‍රතිචාරයෙන් z ඕසේෂ්ට ස්තූතිවන්ත වන අතර, ව්‍යාජ වටිනාකම් සහිත දේපල සම්බන්ධ ගැටළුව නිරාකරණය විය.

Lodash.sortBy භාවිතා කරන්න , (commonjs භාවිතා කරන උපදෙස්, ඔබේ html හි ඉහළින් ඇති cdn සඳහා ස්ක්‍රිප්ට් ඇතුළත්-ටැගය ද තැබිය හැකිය )

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

අවරෝහණ අනුපිළිවෙල

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

නඟින අනුපිළිවෙල

var ascendingOrder = sortBy( homes, '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"
    }
];

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

මම සාදයට ටිකක් පරක්කු නමුත් වර්ග කිරීම සඳහා මගේ තර්කනය පහතින්.

function getSortedData(data, prop, isAsc) {
    return data.sort((a, b) => {
        return (a[prop] < b[prop] ? -1 : 1) * (isAsc ? 1 : -1)
    });
}

OP ට සංඛ්‍යා මාලාවක් වර්ග කිරීමට අවශ්‍ය බව මා දන්නා අතර, මෙම ප්‍රශ්නය නූල් සම්බන්ධ සමාන ප්‍රශ්න සඳහා පිළිතුර ලෙස සලකුණු කර ඇත. එම කාරණයට, ඉහත පිළිතුරු මගින් ආවරණ වැදගත් වන පෙළ පෙළක් වර්ග කිරීම සලකා බලනු නොලැබේ. බොහෝ පිළිතුරු නූල් අගයන් ගෙන ඒවා ලොකු අකුරු / සිම්පල් බවට පරිවර්තනය කර එක් ආකාරයකින් හෝ වෙනත් ආකාරයකින් වර්ග කරන්න. මා පිළිපැදිය යුතු අවශ්‍යතා සරලයි:

• අකාරාදී පිළිවෙලින් AZ වර්ග කරන්න
• කුඩා වචනයට පෙර එකම වචනයේ ඉහළ අගයන් පැමිණිය යුතුය
• එකම අකුරු (A / a, B / b) අගයන් කාණ්ඩගත කළ යුතුය

මා බලාපොරොත්තු වන්නේ [ A, a, B, b, C, c ]ඉහත පිළිතුරු පමණි A, B, C, a, b, c. මට අවශ්‍ය ප්‍රමාණයට වඩා වැඩි කාලයක් මම මේ පිළිබඳව මගේ හිස සීරීමට ලක් කළෙමි. localeCompareසලකුණු කළ පිළිතුර සඳහා පරිශීලකයින් දෙදෙනෙකු අදහස් දැක්වීමේදී ශ්‍රිතය සඳහන් කළද , මම සෙවීමේදී ශ්‍රිතයට බාධා පමුණුවන තුරු මම එය දුටුවේ නැත. String.prototype.localeCompare () ප්‍රලේඛනය කියවීමෙන් පසු මට මෙය ඉදිරිපත් කිරීමට හැකි විය:

var values = [ "Delta", "charlie", "delta", "Charlie", "Bravo", "alpha", "Alpha", "bravo" ];
var sorted = values.sort((a, b) => a.localeCompare(b, undefined, { caseFirst: "upper" }));
// Result: [ "Alpha", "alpha", "Bravo", "bravo", "Charlie", "charlie", "Delta", "delta" ]

සිම්පල් අගයන්ට පෙර ලොකු අකුරු වර්ග කිරීම සඳහා මෙය ශ්‍රිතයට කියයි. localeCompareශ්‍රිතයේ දෙවන පරාමිතිය වන්නේ ප්‍රදේශය නිර්වචනය කිරීමයි, නමුත් ඔබ එය අත්හැරියහොත් undefinedඑය ස්වයංක්‍රීයව ඔබ සඳහා ස්ථානය සොයා ගනී.

වස්තු සමූහයක් වර්ග කිරීම සඳහා මෙය සමාන වේ:

var values = [
    { id: 6, title: "Delta" },
    { id: 2, title: "charlie" },
    { id: 3, title: "delta" },
    { id: 1, title: "Charlie" },
    { id: 8, title: "Bravo" },
    { id: 5, title: "alpha" },
    { id: 4, title: "Alpha" },
    { id: 7, title: "bravo" }
];
var sorted = values
    .sort((a, b) => a.title.localeCompare(b.title, undefined, { caseFirst: "upper" }));

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

ඉහත සියලු පිළිතුරු වල කූටප්‍රාප්තිය මෙන්න.

ෆෙඩල් වලංගුකරණය: http://jsfiddle.net/bobberino/4qqk3/

var sortOn = function (arr, prop, reverse, numeric) {

    // Ensure there's a property
    if (!prop || !arr) {
        return arr
    }

    // Set up sort function
    var sort_by = function (field, rev, primer) {

        // Return the required a,b function
        return function (a, b) {

            // Reset a, b to the field
            a = primer(a[field]), b = primer(b[field]);

            // Do actual sorting, reverse as needed
            return ((a < b) ? -1 : ((a > b) ? 1 : 0)) * (rev ? -1 : 1);
        }

    }

    // Distinguish between numeric and string to prevent 100's from coming before smaller
    // e.g.
    // 1
    // 20
    // 3
    // 4000
    // 50

    if (numeric) {

        // Do sort "in place" with sort_by function
        arr.sort(sort_by(prop, reverse, function (a) {

            // - Force value to a string.
            // - Replace any non numeric characters.
            // - Parse as float to allow 0.02 values.
            return parseFloat(String(a).replace(/[^0-9.-]+/g, ''));

        }));
    } else {

        // Do sort "in place" with sort_by function
        arr.sort(sort_by(prop, reverse, function (a) {

            // - Force value to string.
            return String(a).toUpperCase();

        }));
    }


}

මම යම් ආකාරයක ශ්‍රේණිගත කිරීමක් සහ විවිධ ක්ෂේත්‍ර වර්ග කිරීම සමඟ වැඩ කළෙමි:

arr = [
    {type:'C', note:834},
    {type:'D', note:732},
    {type:'D', note:008},
    {type:'F', note:474},
    {type:'P', note:283},
    {type:'P', note:165},
    {type:'X', note:173},
    {type:'Z', note:239},
];

arr.sort(function(a,b){        
    var _a = ((a.type==='C')?'0':(a.type==='P')?'1':'2');
    _a += (a.type.localeCompare(b.type)===-1)?'0':'1';
    _a += (a.note>b.note)?'1':'0';
    var _b = ((b.type==='C')?'0':(b.type==='P')?'1':'2');
    _b += (b.type.localeCompare(a.type)===-1)?'0':'1';
    _b += (b.note>a.note)?'1':'0';
    return parseInt(_a) - parseInt(_b);
});

ප්‍රති ult ලය

[
    {"type":"C","note":834},
    {"type":"P","note":165},
    {"type":"P","note":283},
    {"type":"D","note":8},
    {"type":"D","note":732},
    {"type":"F","note":474},
    {"type":"X","note":173},
    {"type":"Z","note":239}
]

එය හුදෙක් තනි මාලාවක් තෝරා බේරා ගැනීමේ සඳහා overkill ටිකක් වන අතර, මෙම මූලාකෘති කාර්යය ජාවාස්ක්රිප්ට් අරා සඳහා අවතීර්ණය හෝ අවරෝහණ ක්රමයට, ඕනෑම යතුරක් විසින් නිරාකරණය කිරීමට ඉඩ පිලිතුරු කැදැලි යතුරු ඇතුළු භාවිතා 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)"

ඔබට repo: https://github.com/eneko/Array.sortBy

ECMAScript 6 සමඟ StoBor ගේ පිළිතුර ඊටත් වඩා සංක්ෂිප්තව කළ හැකිය:

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

මිල බැසීමේ අනුපිළිවෙල:

homes.sort((x,y) => {return y.price - x.price})

මිල නැගීමේ අනුපිළිවෙල:

homes.sort((x,y) => {return x.price - y.price})

අරාව වර්ග කිරීම සඳහා ඔබ සංසන්දනාත්මක ශ්‍රිතයක් අර්ථ දැක්විය යුතුය. මෙම ශ්‍රිතය සැමවිටම ඔබ අපේක්ෂිත වර්ග කිරීමේ රටාව හෝ අනුපිළිවෙල අනුව වෙනස් වේ (එනම් නැගීම හෝ බැසයාම).

අරාව නැගීම හෝ බැසයාම වර්ග කරන සහ වස්තු හෝ නූල් හෝ සංඛ්‍යාත්මක අගයන් අඩංගු සමහර කාර්යයන් නිර්මාණය කිරීමට ඉඩ දෙන්න.

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

ඔබ Underscore.js භාවිතා කරන්නේ නම් , sortBy උත්සාහ කරන්න:

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

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

මෙන්න "ජාවාස්ක්‍රිප්ට්: ද ගුඩ් පාට්ස්" පොතෙන් අලංකාර ලෙස ක්‍රියාත්මක කිරීමේ තරමක් වෙනස් කළ සංස්කරණයකි.

සටහන : මෙම අනුවාදය byකියන්නේ ස්ථාවර . ඊළඟ දම්වැල් වර්ග කිරීම සිදු කරන අතර එය පළමු වර්ගයේ අනුපිළිවෙල ආරක්ෂා කරයි.

මම එයට isAscendingපරාමිතිය එකතු කර ඇත්තෙමි . 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"}
// ]

සාමාන්‍ය මූලද්‍රව්‍ය අගයන් සඳහා පමණක්:

function sortArrayOfElements(arrayToSort) {
    function compareElements(a, b) {
        if (a < b)
            return -1;
        if (a > b)
            return 1;
        return 0;
    }

    return arrayToSort.sort(compareElements);
}

e.g. 1:
var array1 = [1,2,545,676,64,2,24]
output : [1, 2, 2, 24, 64, 545, 676]

var array2 = ["v","a",545,676,64,2,"24"]
output: ["a", "v", 2, "24", 64, 545, 676]

වස්තු සමූහයක් සඳහා:

function sortArrayOfObjects(arrayToSort, key) {
    function compareObjects(a, b) {
        if (a[key] < b[key])
            return -1;
        if (a[key] > b[key])
            return 1;
        return 0;
    }

    return arrayToSort.sort(compareObjects);
}

e.g. 1: var array1= [{"name": "User4", "value": 4},{"name": "User3", "value": 3},{"name": "User2", "value": 2}]

output : [{"name": "User2", "value": 2},{"name": "User3", "value": 3},{"name": "User4", "value": 4}]

පහත කේතය භාවිතා කරමින් ආදානය මත පදනම්ව ශ්‍රිතයක් සාදන්න

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"

 }];

 function sortList(list,order){
     if(order=="ASC"){
        return list.sort((a,b)=>{
            return parseFloat(a.price) - parseFloat(b.price);
        })
     }
     else{
        return list.sort((a,b)=>{
            return parseFloat(b.price) - parseFloat(a.price);
        });
     }
 }

 sortList(homes,'DESC');
 console.log(homes);

නූල් සංසන්දනය සඳහා ඔබට string1.localeCompare (string2) භාවිතා කළ හැකිය

this.myArray.sort((a,b) => { 
    return a.stringProp.localeCompare(b.stringProp);
});

බව සටහන localCompareනඩුව තුළ සංවේදී

බහු අරාව වස්තු ක්ෂේත්‍රය මත වර්ග කිරීම සඳහා. ඔබගේ ක්ෂේත්‍ර නාමය arrpropඅරාවෙහි ඇතුළත් කරන්න, ["a","b","c"] ඉන්පසු 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;
}

ඔබට ශ්‍රිත දෙකක් අවශ්‍ය වේ

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

ඔබට එය භාවිතා කිරීමට අවශ්‍ය නම් මෙය කළමනාකරණය කිරීම සඳහා මම මෑතකදී විශ්වීය ශ්‍රිතයක් ලිවීය.

/**
 * Sorts an object into an order
 *
 * @require jQuery
 *
 * @param object Our JSON object to sort
 * @param type Only alphabetical at the moment
 * @param identifier The array or object key to sort by
 * @param order Ascending or Descending
 *
 * @returns Array
 */
function sortItems(object, type, identifier, order){

    var returnedArray = [];
    var emptiesArray = []; // An array for all of our empty cans

    // Convert the given object to an array
    $.each(object, function(key, object){

        // Store all of our empty cans in their own array
        // Store all other objects in our returned array
        object[identifier] == null ? emptiesArray.push(object) : returnedArray.push(object);

    });

    // Sort the array based on the type given
    switch(type){

        case 'alphabetical':

            returnedArray.sort(function(a, b){

                return(a[identifier] == b[identifier]) ? 0 : (

                    // Sort ascending or descending based on order given
                    order == 'asc' ? a[identifier] > b[identifier] : a[identifier] < b[identifier]

                ) ? 1 : -1;

            });

            break;

        default:

    }

    // Return our sorted array along with the empties at the bottom depending on sort order
    return order == 'asc' ? returnedArray.concat(emptiesArray) : emptiesArray.concat(returnedArray);

}

homes.sort(function(a, b){
  var nameA=a.prices.toLowerCase(), nameB=b.prices.toLowerCase()
  if (nameA < nameB) //sort string ascending
    return -1 
  if (nameA > nameB)
    return 1
  return 0 //default return value (no sorting)
})

ආයුබෝවන් මෙම ලිපිය කියවීමෙන් පසු, මම මගේ අවශ්‍යතා සඳහා වර්ගීකරණ සංසන්දකයෙකු සෑදුවෙමි, ජේසන් ගුණාංග එකකට වඩා සංසන්දනය කිරීමේ ක්‍රියාකාරීත්වය සමඟ, එය ඔබ සමඟ බෙදා ගැනීමට මට අවශ්‍යය.

මෙම විසඳුම සංසන්දනය කරන්නේ නූලට නඟින අනුපිළිවෙලට පමණි, නමුත් විසඳුම එක් එක් ගුණාංග සඳහා සහය දැක්වීම සඳහා පහසුවෙන් දිගු කළ හැකිය: ප්‍රතිලෝම ඇණවුම් කිරීම, වෙනත් දත්ත වර්ග, පෙදෙසි භාවිතා කිරීම, වාත්තු කිරීම යනාදිය

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"

}];

// comp = array of attributes to sort
// comp = ['attr1', 'attr2', 'attr3', ...]
function sortComparator(a, b, comp) {
    // Compare the values of the first attribute
    if (a[comp[0]] === b[comp[0]]) {
        // if EQ proceed with the next attributes
        if (comp.length > 1) {
            return sortComparator(a, b, comp.slice(1));
        } else {
            // if no more attributes then return EQ
            return 0;
        }
    } else {
        // return less or great
        return (a[comp[0]] < b[comp[0]] ? -1 : 1)
    }
}

// Sort array homes
homes.sort(function(a, b) {
    return sortComparator(a, b, ['state', 'city', 'zip']);
});

// display the array
homes.forEach(function(home) {
    console.log(home.h_id, home.city, home.state, home.zip, home.price);
});

ප්‍රති result ලය

$ node sort
4 Bevery Hills CA 90210 319250
5 New York NY 00010 962500
3 Dallas TX 75201 162500

තවත් වර්ගයක්

homes.sort(function(a, b) {
    return sortComparator(a, b, ['city', 'zip']);
});

ප්‍රති .ලය සමඟ

$ node sort
4 Bevery Hills CA 90210 319250
3 Dallas TX 75201 162500
5 New York NY 00010 962500

සරල කේතයක්:

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

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

    for (var i=0; i<sortByPrice.length; i++)
    {
      document.write(sortByPrice[i].h_id+' '+sortByPrice[i].city+' '
       +sortByPrice[i].state+' '
       +sortByPrice[i].zip+' '+sortByPrice[i].price);
      document.write("<br>");
    }

 function compareValues(key, order = 'asc') {
  return function innerSort(a, b) {
    if (!a.hasOwnProperty(key) || !b.hasOwnProperty(key)) {
      // property doesn't exist on either object
      return 0;
    }

    const varA = (typeof a[key] === 'string')
      ? a[key].toUpperCase() : a[key];
    const varB = (typeof b[key] === 'string')
      ? b[key].toUpperCase() : b[key];

    let comparison = 0;
    if (varA > varB) {
      comparison = 1;
    } else if (varA < varB) {
      comparison = -1;
    }
    return (
      (order === 'desc') ? (comparison * -1) : comparison
    );
  };
}

http://yazilimsozluk.com/sort-array-in-javascript-by-asc-or-desc