javascript - জাভাস্ক্রিপ্ট বস্তুর একটি অ্যারের সাজানোর



arrays sorting (17)

ECMAScript 6 স্টোবরের উত্তরটি আরও সংক্ষিপ্ত করতে পারে:

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

https://rueisnom.com

আমি অজ্যাক্স ব্যবহার করে নিম্নলিখিত বস্তুগুলি পড়েছি এবং একটি অ্যারেতে সেগুলি সংরক্ষণ করেছি:

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

কীভাবে আমি কেবলমাত্র জাভাস্ক্রিপ্ট ব্যবহার করে উচ্চতর বা নিম্নমানের ক্রম অনুসারে বস্তুর সাজানোর বস্তুগুলি সাজানোর জন্য একটি ফাংশন তৈরি করব?


Answer #1

আপনি একটি কলব্যাক ফাংশন দিয়ে জাভাস্ক্রিপ্ট 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);

Answer #2

আপনি দুটি ফাংশন প্রয়োজন হবে

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


Answer #3

আপনি যদি 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);}); 

Answer #4

আমি গিটহুবকে সুপারিশ করি : অ্যারে sortbyby - শাওয়ার্টিজিয়ান ট্রান্সফর্ম ব্যবহার করে sortBy পদ্ধতির সর্বোত্তম বাস্তবায়ন

কিন্তু এখন আমরা এই পদ্ধতির চেষ্টা করতে যাচ্ছি জিস্টঃ sortbyy-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

@ ওজেশকে তার প্রতিক্রিয়ার কারণে ধন্যবাদ, মিথ্যা সমস্যাগুলির সাথে সম্পৃক্ত বিষয়গুলি সংশোধন করা হয়েছে।


Answer #5

আমি কিছু ধরনের রেটিং এবং একাধিক ক্ষেত্র সাজানোর সাথে কাজ করেছি:

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

ফল

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

Answer #6

একটি অ্যারের সাজানোর জন্য আপনি একটি তুলনাকারী ফাংশন সংজ্ঞায়িত করা আবশ্যক। এই ফাংশন সবসময় আপনার পছন্দসই বাছাই প্যাটার্ন বা আদেশ (অর্থাত্ ঊর্ধ্বমুখী বা অবতরণ) ভিন্ন হতে।

অ্যারে ঊর্ধ্বমুখী বা নিম্নমানের সাজানোর যে কিছু ফাংশন তৈরি করা যাক এবং যে বস্তু বা স্ট্রিং বা সাংখ্যিক মান রয়েছে।

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

Answer #7

একাধিক অ্যারে বস্তু ক্ষেত্রের উপর সাজানোর জন্য। 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;
}

Answer #8

এখানে আরও একটি নমনীয় সংস্করণ, যা আপনাকে পুনঃব্যবহারযোগ্য সাজানোর ফাংশন তৈরি করতে এবং যে কোনও ক্ষেত্র অনুসারে সাজানোর অনুমতি দেয়।

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

Answer #9

এখানে উপরের সব উত্তর একটি পরিণাম হয়।

ফীল্ড বৈধতা: 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();

        }));
    }


}

Answer #10

এটি একটি সহজ এক লাইন মান () সাজানোর ফাংশন মাধ্যমে অর্জন করা হতে পারে। ডেমো দেখতে নীচের কোড স্নিপেট চালান।

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


Answer #11

এটি সাজানোর জন্য আপনি দুটি আর্গুমেন্ট গ্রহণ একটি তুলনাকারী ফাংশন তৈরি করতে হবে। তারপর নিম্নরূপ যে তুলনাকারী ফাংশন সঙ্গে সাজানোর ফাংশন কল:

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

যদি আপনি ঊর্ধ্বমুখী স্যুইচটি সঙ্কুচিত সাইনের প্রতিটি পাশে এক্সপ্রেশনগুলি সরাতে চান।


Answer #12

যদি আপনার কোন 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);


Answer #13

যদিও আমি সচেতন যে অপারেটিং সিস্টেমের সংখ্যাগুলি সাজানোর চেষ্টা করা উচিত, এই প্রশ্নটি স্ট্রিং সম্পর্কিত একই প্রশ্নগুলির উত্তর হিসাবে চিহ্নিত করা হয়েছে। যে ক্ষেত্রে, উপরের উত্তরগুলি পাঠ্যক্রমের অ্যারে সাজানোর বিবেচনা করে না যেখানে ক্যাসিং গুরুত্বপূর্ণ। সর্বাধিক উত্তর স্ট্রিং মান গ্রহণ করে এবং তাদের বড় হাতের অক্ষর / ছোট হাতের অক্ষরে রূপান্তর করে এবং তারপর একরকম বা অন্যটি সাজায়। আমি যে প্রয়োজনীয়তা অনুসরণ করা সহজ হয়:

  • বর্ণানুক্রমিকভাবে AZ সাজান
  • একই শব্দ উচ্চ অক্ষর মান ছোট হাতের মান আগে আসা উচিত
  • একই অক্ষর (A / A, B / B) মান একসাথে গোষ্ঠীবদ্ধ করা উচিত

আমি কি আশা করি [ A, a, B, b, C, c ] কিন্তু উপরের উত্তরগুলি উত্তর A, B, C, a, b, c । আমি আসলে চেয়ে চেয়ে বেশি সময় ধরে আমার মাথার উপর চাপিয়ে দিয়েছি (এই কারণে আমি আশা করছি এটি অন্তত একজন অন্য ব্যক্তির সাহায্য করবে)। যদিও দুটি ব্যবহারকারী চিহ্নিত উত্তরটির জন্য মন্তব্যগুলিতে localeCompare ফাংশনটি উল্লেখ করেছেন, তখন আমি দেখিনি যে localeCompare সময় localeCompare ফাংশনটির উপর localeCompare হয়ে localeCompareString.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 হিসাবে ছেড়ে যান তবে এটি স্বয়ংক্রিয়ভাবে আপনার জন্য লোকেলকে localeCompare করে।

বস্তুর অ্যারে সাজানোর জন্য এটি একই কাজ করে:

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

Answer #14

স্ট্রিং সাজানোর জন্য কেউ প্রয়োজন হলে,

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

Answer #15

হাই এই নিবন্ধটি পড়ার পর, আমি আমার প্রয়োজনের জন্য একটি সাজানোর কম্পোপারেটর তৈরি করেছি, একাধিক জson বৈশিষ্ট্যগুলির তুলনা করার কার্যকারিতা সহ এবং আমি এটি আপনার সাথে ভাগ করতে চাই।

এই সমাধানটি কেবলমাত্র ক্রমবর্ধমান ক্রমের সাথে তুলনা করে, তবে সমাধানটি প্রতিটি বৈশিষ্ট্যকে সমর্থন করার জন্য সহজে বর্ধিত করা যেতে পারে: বিপরীত ক্রম, অন্যান্য ডাটা প্রকার, লোকেল, কাস্টিং ইত্যাদি ব্যবহার করতে

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

এবং ফলাফল হয়

$ 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

Answer #16
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)
})





sorting