একাধিক ক্ষেত্র দ্বারা বস্তুর একটি অ্যারে বাছাই কিভাবে?

147

এই আসল প্রশ্ন থেকে , আমি একাধিক ক্ষেত্রের মধ্যে বাছাই কিভাবে করব?

এই সামান্য অভিযোজিত কাঠামোটি ব্যবহার করে, আমি কীভাবে শহর বাছাই করব (আরোহণ) এবং তারপরে দাম (উতরাই)?

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":"6",
     "city":"Dallas",
     "state":"TX",
     "zip":"75000",
     "price":"556699"},
    {"h_id":"5",
     "city":"New York",
     "state":"NY",
     "zip":"00010",
     "price":"962500"}
    ];

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

আমি এই উত্তরটি একটি দুর্দান্ত জেনেরিক উদাহরণ হিসাবে গড়ে তোলার চেষ্টা করেছি , তবে আমার খুব ভাগ্য নেই।

javascript  arrays  sorting 
— মাইক
সূত্র
আপনি অনুসন্ধান বা বাছাই করতে চান?
— ফেলিক্স ক্লিং
আপনি যুক্ত করেছেন দ্বিতীয় উত্তরটি ব্যবহার করার সাথে ঠিক কী সমস্যা হচ্ছে?
— ক্যানন
এটি যথেষ্ট জেনেরিক নয়। আমি কোডের সমুদ্র যুক্ত করব বলে মনে হচ্ছে যখন আমি কেবল বলতে চাই যে sort(["first-field", "ASC"], ["second-field", "DSC"]); এটি আরও জটিল যখন আমি প্রথম উত্তরের "প্রাইমার" যুক্তি যুক্ত করার চেষ্টা করি যাতে আমি তারিখগুলি, কেস-সংবেদনশীলতা ইত্যাদি পরিচালনা করতে পারি
— মাইক
অথবা আপনি প্রতিটি ক্ষেত্রে একটি ওজন প্রয়োগ করতে পারেন
— onmyway133
আপনি ল্যাড্যাশ / ডকস / ৪.১7.১১## অর্ডারটি পরীক্ষা করে দেখতে পারেন, আপনি যদি লোডাশ ব্যবহার করছেন ঠিক আছে
— দীপংশু অরোরা

উত্তর:

83

এই উত্তরের ভিত্তিতে একটি বহুমাত্রিক বাছাই করার পদ্ধতি :

আপডেট : এখানে একটি "অনুকূলিতকরণ" সংস্করণ। এটি আরও অনেক প্রাক-প্রসেসিং করে এবং প্রতিটি বাছাইয়ের বিকল্পের আগে একটি তুলনা ফাংশন তৈরি করে। এটি আরও বেশি মেমরির প্রয়োজন হতে পারে (এটি প্রতিটি বাছাইকরণ বিকল্পের জন্য একটি ফাংশন সঞ্চয় করে তবে এটি তুলনাকালীন সঠিক সেটিংস নির্ধারণ করতে হবে না কারণ এটি কিছুটা আরও ভালভাবে প্রবর্তন করা উচিত though যদিও আমি কোনও প্রোফাইলিং করি নি।

var sort_by;

(function() {
    // utility functions
    var default_cmp = function(a, b) {
            if (a == b) return 0;
            return a < b ? -1 : 1;
        },
        getCmpFunc = function(primer, reverse) {
            var dfc = default_cmp, // closer in scope
                cmp = default_cmp;
            if (primer) {
                cmp = function(a, b) {
                    return dfc(primer(a), primer(b));
                };
            }
            if (reverse) {
                return function(a, b) {
                    return -1 * cmp(a, b);
                };
            }
            return cmp;
        };

    // actual implementation
    sort_by = function() {
        var fields = [],
            n_fields = arguments.length,
            field, name, reverse, cmp;

        // preprocess sorting options
        for (var i = 0; i < n_fields; i++) {
            field = arguments[i];
            if (typeof field === 'string') {
                name = field;
                cmp = default_cmp;
            }
            else {
                name = field.name;
                cmp = getCmpFunc(field.primer, field.reverse);
            }
            fields.push({
                name: name,
                cmp: cmp
            });
        }

        // final comparison function
        return function(A, B) {
            var a, b, name, result;
            for (var i = 0; i < n_fields; i++) {
                result = 0;
                field = fields[i];
                name = field.name;

                result = field.cmp(A[name], B[name]);
                if (result !== 0) break;
            }
            return result;
        }
    }
}());

ব্যবহারের উদাহরণ:

homes.sort(sort_by('city', {name:'price', primer: parseInt, reverse: true}));

ডেমো

আসল ফাংশন:

var sort_by = function() {
   var fields = [].slice.call(arguments),
       n_fields = fields.length;

   return function(A,B) {
       var a, b, field, key, primer, reverse, result, i;

       for(i = 0; i < n_fields; i++) {
           result = 0;
           field = fields[i];

           key = typeof field === 'string' ? field : field.name;

           a = A[key];
           b = B[key];

           if (typeof field.primer  !== 'undefined'){
               a = field.primer(a);
               b = field.primer(b);
           }

           reverse = (field.reverse) ? -1 : 1;

           if (a<b) result = reverse * -1;
           if (a>b) result = reverse * 1;
           if(result !== 0) break;
       }
       return result;
   }
};

ডেমো

— ফেলিক্স ক্লিং
সূত্র
2
রেকর্ডের জন্য, এই ফাংশনটি তবুও যুক্তি তালিকার প্রাক-প্রসেসিংয়ের মাধ্যমে উন্নত করা যেতে পারে এবং একটি অভিন্ন "বাছাই করা বিকল্প অ্যারে" তৈরি করে। এটি পাঠকের জন্য অনুশীলন হিসাবে ছেড়ে গেছে;)
— ফেলিক্স ক্লিং
@ মাইক: ঠিক আছে ... অবশেষে;) আপনি দেখতে পাচ্ছেন যে এটি এখন আরও জটিল, কারণ বিকল্পগুলি প্রাক-প্রক্রিয়াজাত করা হয়েছে, তবে চূড়ান্ত তুলনা কার্য (মন্তব্য দেখুন) অনেক সহজ যা (আশা করি) আরও ভাল পারফরম্যান্সের দিকে নিয়ে যায়। আপনার যত বেশি বাছাইয়ের বিকল্প রয়েছে, এই পদ্ধতিটি থেকে আপনার আরও সুবিধা হবে।
— ফেলিক্স ক্লিং
165

আপনার সঠিক সমস্যার একটি জেনারিক, সাধারণ সমাধানের জন্য:

homes.sort(
   function(a, b) {          
      if (a.city === b.city) {
         // Price is only important when cities are the same
         return b.price - a.price;
      }
      return a.city > b.city ? 1 : -1;
   });
— Snowburnt
সূত্র
6
আমি মনে করি এই ডেমোটি ওপি যা চায় == jsfiddle.net/zJ6UA/533
— আমিন জাফারি
3
এটিতে সঠিক ধারণা রয়েছে তবে যুক্তিটি সমস্ত ভুল। আপনি অন্য স্ট্রিং থেকে একটি অ-সংখ্যাসূচক স্ট্রিং বিয়োগ করতে পারবেন না এবং ifবিবৃতিটি কোনও অর্থ দেয় না।
— জেএলরিশ
6
আপনি a.localeCompare(b)স্ট্রিং তুলনার জন্য শেষ লাইনে ব্যবহার করতে পারেন ... ডকগুলি দেখুন
— মাইকেল পি
2
প্রথম শহরের তুলনাটি কি অসামতার জন্য নয়, সাম্যের জন্য অনুসন্ধান করা উচিত? অন্য কথায়, লাইনটি হওয়া উচিত নয় if (a.city === b.city)? অর্থাৎ, দুটি শহর যদি একই হয় তবে দামের তুলনা করুন, অন্যথায় শহরগুলির তুলনা করুন।
— স্টিভেন র‌্যান্ডস 15
2
সেরা উত্তর এক। tnx।
— জোনাথানা
54

আপনি শূন্যের সমান নয় এমন মান না পৌঁছানো অবধি মানগুলির ব-দ্বীপ গ্রহণ করে একটি শৃঙ্খলাবদ্ধ বাছাই পদ্ধতি ব্যবহার করতে পারেন।

var data = [{ 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: "6", city: "Dallas", state: "TX", zip: "75000", price: "556699" }, { h_id: "5", city: "New York", state: "NY", zip: "00010", price: "962500" }];

data.sort(function (a, b) {
    return a.city.localeCompare(b.city) || b.price - a.price;
});

console.log(data);
.as-console-wrapper { max-height: 100% !important; top: 0; }
স্নিপেট প্রসারিত করুন

অথবা, এস 6 ব্যবহার করে, সহজভাবে:

data.sort((a, b) => a.city.localeCompare(b.city) || b.price - a.price);
— নিনা শোল্জ
সূত্র
16
আমি কিছু অনুপস্থিত করছি? 1-এ করা যেতে পারে এমন কোনও কিছুর জন্য কেন 60 লাইন কোড ব্যবহার করুন Simple স্বীকৃত উত্তর আইএমও হওয়া উচিত।
— এরেজ কোহেন
এসও-র এখনকার অন্যতম বড় সমস্যা হ'ল সেই পুরানো উত্তরগুলি - প্রায়শই নতুন ভাষার বৈশিষ্ট্যগুলি (যেমন ES5-6-7) ব্যবহার করে আরও ভাল সমাধানগুলি দ্বারা তাদের পুরানো স্কোরগুলি বজায় রাখা ভাল হয় এবং আমরা সবাই "সত্যিকারের" সেরা খুঁজে পেতে নীচে স্ক্রোল করতে হয় have সমাধান! এটির সমাধানের জন্য এসও'র ভোটের মেয়াদ উত্তীর্ণ হওয়া উচিত, কারণ সময় পার হওয়ার সাথে সাথে সমস্যাটি আরও খারাপ হচ্ছে।
— অ্যান্ডি লরেঞ্জ
53

এখানে একটি সহজ ক্রিয়ামূলক পদ্ধতির। অ্যারে ব্যবহার করে সাজানোর ক্রম নির্দিষ্ট করুন। শুরুতে যোগ বিয়োগ অর্ডার সাজানো নির্দিষ্ট করতে।

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":"6", "city":"Dallas", "state":"TX", "zip":"75000", "price":"556699"},
    {"h_id":"5", "city":"New York", "state":"NY", "zip":"00010", "price":"962500"}
    ];

homes.sort(fieldSorter(['city', '-price']));
// homes.sort(fieldSorter(['zip', '-state', 'price'])); // alternative

function fieldSorter(fields) {
    return function (a, b) {
        return fields
            .map(function (o) {
                var dir = 1;
                if (o[0] === '-') {
                   dir = -1;
                   o=o.substring(1);
                }
                if (a[o] > b[o]) return dir;
                if (a[o] < b[o]) return -(dir);
                return 0;
            })
            .reduce(function firstNonZeroValue (p,n) {
                return p ? p : n;
            }, 0);
    };
}

সম্পাদনা: ES6 এ এটি আরও খাটো!

"use strict";
const fieldSorter = (fields) => (a, b) => fields.map(o => {
    let dir = 1;
    if (o[0] === '-') { dir = -1; o=o.substring(1); }
    return a[o] > b[o] ? dir : a[o] < b[o] ? -(dir) : 0;
}).reduce((p, n) => p ? p : n, 0);

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":"6", "city":"Dallas", "state":"TX", "zip":"75000", "price":556699},{"h_id":"5", "city":"New York", "state":"NY", "zip":"00010", "price":962500}];
const sortedHomes = homes.sort(fieldSorter(['state', '-price']));

document.write('<pre>' + JSON.stringify(sortedHomes, null, '\t') + '</pre>')
স্নিপেট প্রসারিত করুন

— chriskelly
সূত্র
6
আমি এই ফাংশনটি বেশ ঝরঝরে পেয়েছি সুতরাং আমি পার্সারের উপর নির্ভর করে 90% পর্যন্ত একটি ছোট পারফরম্যান্স উন্নতি করেছি। আমি একটি গিস্ট এবং টেস্ট স্যুট তৈরি করেছি ।
— php_nub_qq
নমুনা তথ্য এটি সংখ্যার মত দেখায় উপর ভিত্তি করে আশানুরূপ সাজানো হয়, তবে আমি যখন যেখানে আরো স্ট্রিং মত বাছাই এই সংখ্যার বাস্তবায়নের চেষ্টা ... [10,100,11,9]। আমি কি কিছু রেখে গেলাম?
— মার্ক কার্পেন্টার জুনিয়র
@MarkCarpenterJr। আপনি কি বোঝাতে চেয়েছেন তা নিশ্চিত না। আমার উদাহরণটি সাংখ্যিক প্রকারকে সঠিকভাবে বাছাই করে। আপনি কি আপনার বাস্তবায়নটিকে প্রশ্ন হিসাবে ভাগ করে নিতে পারেন এবং মন্তব্যে আমাকে উল্লেখ করতে পারেন যাতে আমি এটি দেখতে পারি? তারপরে আমি চেক করতে পারি।
— ক্রিস্কেল ২
@MarkCarpenterJr। শুধু এটি স্পট। আমি মন্তব্যগুলিতে একটি ব্যাখ্যা যুক্ত করেছি।
— ক্রিস্কেললি
32

আমি আজ বেশ জেনেরিক মাল্টি ফিচার বাছাই করেছি। আপনি তখন বাই বাই.জেএস এ একবার দেখতে পারেন: https://github.com/Teun/thenBy.js

এটি আপনাকে স্ট্যান্ডার্ড অ্যারে.সোর্টটি ব্যবহার করতে দেয় তবে ফার্স্ট বাই () এর সাথে .তখন বাই () .তখন বাই () স্টাইল ব্যবহার করে। এটি উপরে পোস্ট করা সমাধানগুলির চেয়ে কম কোড এবং জটিলতা।

— টিউন ডি
সূত্র
8
ঠিক আছে, আপনি যখন 3 বার কল করবেন তখন দ্বিতীয় কলটি এমন আইটেমগুলির জন্য যেখানে দ্বিতীয় কলটির কোনও তাত্পর্য হয় না তার জন্য প্রথমে অচ্ছুত অর্ডার ছেড়ে দেওয়ার নিশ্চয়তা দেওয়া হয় না।
— টিউন ডি
13

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

প্রথম আর্গুমেন্টটি অবশ্যই অ্যারেগুলি যুক্ত করে be পরবর্তী যুক্তি (গুলি) অবশ্যই কমা দ্বারা পৃথক হওয়া স্ট্রিংয়ের তালিকা হতে হবে যা অনুসারে বাছাই করতে বিভিন্ন বস্তুর বৈশিষ্ট্যকে উল্লেখ করে। কেস সংবেদনশীল প্রকারগুলি সম্পাদন করতে হবে কিনা তা চয়ন করার জন্য শেষ যুক্তি (যা alচ্ছিক) একটি বুলিয়ান case কেস সংবেদনশীল ধরণের trueজন্য ব্যবহার করুন ।

ফাংশনটি প্রতিটি সম্পত্তি / কীটিকে পূর্বনির্ধারিতভাবে আরোহণের ক্রমে সাজিয়ে রাখবে। আপনি অবরোহী বাছাই করতে একটি বিশেষ কী চান, তাহলে এর বদলে এই বিন্যাসে একটি অ্যারের মধ্যে পাস: ['property_name', true]।

এখানে ফাংশনটির কয়েকটি নমুনা ব্যবহার রয়েছে যার পরে একটি ব্যাখ্যা রয়েছে (যেখানে homesঅ্যারেটি অবজেক্টস রয়েছে):

objSort(homes, 'city') -> শহর অনুসারে বাছাই করুন (আরোহণ, সংবেদনশীল ক্ষেত্রে)

objSort(homes, ['city', true]) -> শহর অনুসারে বাছাই করুন (অবতরণ, সংবেদনশীল ক্ষেত্রে)

objSort(homes, 'city', true)-> শহর অনুসারে বাছাই করুন তারপর দাম (আরোহণ, কেস সংবেদনশীল )

objSort(homes, 'city', 'price') -> শহর অনুসারে বাছাই করুন তারপরে দাম (আরোহী উভয় ক্ষেত্রে সংবেদনশীল)

objSort(homes, 'city', ['price', true]) -> শহর অনুসারে বাছাই করুন (আরোহণ) তারপরে দাম (উতরাই), সংবেদনশীল ক্ষেত্রে)

এবং আরও অ্যাডো ছাড়া, এখানে ফাংশনটি রয়েছে:

function objSort() {
    var args = arguments,
        array = args[0],
        case_sensitive, keys_length, key, desc, a, b, i;

    if (typeof arguments[arguments.length - 1] === 'boolean') {
        case_sensitive = arguments[arguments.length - 1];
        keys_length = arguments.length - 1;
    } else {
        case_sensitive = false;
        keys_length = arguments.length;
    }

    return array.sort(function (obj1, obj2) {
        for (i = 1; i < keys_length; i++) {
            key = args[i];
            if (typeof key !== 'string') {
                desc = key[1];
                key = key[0];
                a = obj1[args[i][0]];
                b = obj2[args[i][0]];
            } else {
                desc = false;
                a = obj1[args[i]];
                b = obj2[args[i]];
            }

            if (case_sensitive === false && typeof a === 'string') {
                a = a.toLowerCase();
                b = b.toLowerCase();
            }

            if (! desc) {
                if (a < b) return -1;
                if (a > b) return 1;
            } else {
                if (a > b) return -1;
                if (a < b) return 1;
            }
        }
        return 0;
    });
} //end of objSort() function

এবং এখানে কিছু নমুনা ডেটা:

var homes = [{
    "h_id": "3",
    "city": "Dallas",
    "state": "TX",
    "zip": "75201",
    "price": 162500
}, {
    "h_id": "4",
    "city": "Bevery Hills",
    "state": "CA",
    "zip": "90210",
    "price": 1000000
}, {
    "h_id": "5",
    "city": "new york",
    "state": "NY",
    "zip": "00010",
    "price": 1000000
}, {
    "h_id": "6",
    "city": "Dallas",
    "state": "TX",
    "zip": "85000",
    "price": 300000
}, {
    "h_id": "7",
    "city": "New York",
    "state": "NY",
    "zip": "00020",
    "price": 345000
}];
— জেক
সূত্র
8

এটি সম্পূর্ণ প্রতারণা তবে আমি মনে করি এটি এই প্রশ্নের মান যোগ করে কারণ এটি মূলত একটি ক্যানড লাইব্রেরি ফাংশন যা আপনি বাক্সের বাইরে ব্যবহার করতে পারেন।

যদি আপনার lodashকোডটিতে অ্যাক্সেস থাকে বা কোনও লড্যাশ সুসংগত লাইব্রেরি থাকে underscoreতবে আপনি এই _.sortByপদ্ধতিটি ব্যবহার করতে পারেন । নীচের স্নিপেটটি সরাসরি লোডাস ডকুমেন্টেশন থেকে অনুলিপি করা হয় ।

উদাহরণগুলিতে মন্তব্য করা ফলাফলগুলি দেখে মনে হচ্ছে তারা অ্যারের অ্যারে ফিরিয়েছে তবে এটি কেবল অর্ডারটি দেখাচ্ছে এবং আসল ফলাফলগুলি যা বস্তুর অ্যারে নয়।

var users = [
  { 'user': 'fred',   'age': 48 },
  { 'user': 'barney', 'age': 36 },
  { 'user': 'fred',   'age': 40 },
  { 'user': 'barney', 'age': 34 }
];

_.sortBy(users, [function(o) { return o.user; }]);
 // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]

_.sortBy(users, ['user', 'age']);
// => objects for [['barney', 34], ['barney', 36], ['fred', 40], ['fred', 48]]
— লোক
সূত্র
7

এখানে আরও একটি যা সম্ভবত সিনট্যাক্সের জন্য আপনার ধারণার নিকটবর্তী

function sortObjects(objArray, properties /*, primers*/) {
    var primers = arguments[2] || {}; // primers are optional

    properties = properties.map(function(prop) {
        if( !(prop instanceof Array) ) {
            prop = [prop, 'asc']
        }
        if( prop[1].toLowerCase() == 'desc' ) {
            prop[1] = -1;
        } else {
            prop[1] = 1;
        }
        return prop;
    });

    function valueCmp(x, y) {
        return x > y ? 1 : x < y ? -1 : 0; 
    }

    function arrayCmp(a, b) {
        var arr1 = [], arr2 = [];
        properties.forEach(function(prop) {
            var aValue = a[prop[0]],
                bValue = b[prop[0]];
            if( typeof primers[prop[0]] != 'undefined' ) {
                aValue = primers[prop[0]](aValue);
                bValue = primers[prop[0]](bValue);
            }
            arr1.push( prop[1] * valueCmp(aValue, bValue) );
            arr2.push( prop[1] * valueCmp(bValue, aValue) );
        });
        return arr1 < arr2 ? -1 : 1;
    }

    objArray.sort(function(a, b) {
        return arrayCmp(a, b);
    });
}

// just for fun use this to reverse the city name when sorting
function demoPrimer(str) {
    return str.split('').reverse().join('');
}

// Example
sortObjects(homes, ['city', ['price', 'desc']], {city: demoPrimer});

ডেমো: http://jsfiddle.net/Nq4dk/2/

সম্পাদনা: কেবল মজাদার জন্য, এখানে একটি ভিন্নতা রয়েছে যা কেবল স্কল-জাতীয় স্ট্রিং নেয়, তাই আপনি এটি করতে পারেনsortObjects(homes, "city, price desc")

function sortObjects(objArray, properties /*, primers*/) {
    var primers = arguments[2] || {};

    properties = properties.split(/\s*,\s*/).map(function(prop) {
        prop = prop.match(/^([^\s]+)(\s*desc)?/i);
        if( prop[2] && prop[2].toLowerCase() === 'desc' ) {
            return [prop[1] , -1];
        } else {
            return [prop[1] , 1];
        }
    });

    function valueCmp(x, y) {
        return x > y ? 1 : x < y ? -1 : 0; 
    }

    function arrayCmp(a, b) {
        var arr1 = [], arr2 = [];
        properties.forEach(function(prop) {
            var aValue = a[prop[0]],
                bValue = b[prop[0]];
            if( typeof primers[prop[0]] != 'undefined' ) {
                aValue = primers[prop[0]](aValue);
                bValue = primers[prop[0]](bValue);
            }
            arr1.push( prop[1] * valueCmp(aValue, bValue) );
            arr2.push( prop[1] * valueCmp(bValue, aValue) );
        });
        return arr1 < arr2 ? -1 : 1;
    }

    objArray.sort(function(a, b) {
        return arrayCmp(a, b);
    });
}
— Flambino
সূত্র
এই সমাধানটি পরিষ্কার তবে অভিনব নয় কারণ অ্যারের তুলনায় comparison আপনি কেবল বৈশিষ্ট্যগুলির মাধ্যমে তুলনামূলক মানটি ট্র্যাক করে রাখুন এবং এটি শূন্য নয়, ফিরে আসুন। এটা অনেক দ্রুত
— আমঙ্কাপুর91
4

সহজ একটি:

var someArray = [...];

function generateSortFn(props) {
    return function (a, b) {
        for (var i = 0; i < props.length; i++) {
            var prop = props[i];
            var name = prop.name;
            var reverse = prop.reverse;
            if (a[name] < b[name])
                return reverse ? 1 : -1;
            if (a[name] > b[name])
                return reverse ? -1 : 1;
        }
        return 0;
    };
};

someArray.sort(generateSortFn([{name: 'prop1', reverse: true}, {name: 'prop2'}]));
— রওশন সমানদারভ
সূত্র
3

আমি স্নোবার্টের অ্যাপ্রোচ পছন্দ করি তবে শহরের পার্থক্য নয় পার্থক্য পরীক্ষা করার জন্য এটি একটি টুইঙ্ক দরকার।

homes.sort(
   function(a,b){
      if (a.city==b.city){
         return (b.price-a.price);
      } else {
         return (a.city-b.city);
      }
   });
— জেমস কেনে
সূত্র
3

এখানে প্রতিটি জেনেরিক বহুমাত্রিক বাছাই করা হয়েছে, প্রতিটি স্তরে বিপরীত পরিবর্তন এবং / অথবা ম্যাপিংয়ের জন্য।

টাইপস্ক্রিপ্ট লিখিত। জাভাস্ক্রিপ্টের জন্য, এই জেএসফিডালটি দেখুন

কোড

type itemMap = (n: any) => any;

interface SortConfig<T> {
  key: keyof T;
  reverse?: boolean;
  map?: itemMap;
}

export function byObjectValues<T extends object>(keys: ((keyof T) | SortConfig<T>)[]): (a: T, b: T) => 0 | 1 | -1 {
  return function(a: T, b: T) {
    const firstKey: keyof T | SortConfig<T> = keys[0];
    const isSimple = typeof firstKey === 'string';
    const key: keyof T = isSimple ? (firstKey as keyof T) : (firstKey as SortConfig<T>).key;
    const reverse: boolean = isSimple ? false : !!(firstKey as SortConfig<T>).reverse;
    const map: itemMap | null = isSimple ? null : (firstKey as SortConfig<T>).map || null;

    const valA = map ? map(a[key]) : a[key];
    const valB = map ? map(b[key]) : b[key];
    if (valA === valB) {
      if (keys.length === 1) {
        return 0;
      }
      return byObjectValues<T>(keys.slice(1))(a, b);
    }
    if (reverse) {
      return valA > valB ? -1 : 1;
    }
    return valA > valB ? 1 : -1;
  };
}

ব্যবহারের উদাহরণ

পদবী দ্বারা একটি ব্যক্তিকে অ্যারে বাছাই করা হচ্ছে, তারপরে প্রথম নাম:

interface Person {
  firstName: string;
  lastName: string;
}

people.sort(byObjectValues<Person>(['lastName','firstName']));

তাদের দ্বারা বাছাই ভাষা কোডের নাম , না তাদের ভাষা কোড (দেখুন map), তারপর দ্বারা সাজানো সংস্করণ (দেখুন reverse)।

interface Language {
  code: string;
  version: number;
}

// languageCodeToName(code) is defined elsewhere in code

languageCodes.sort(byObjectValues<Language>([
  {
    key: 'code',
    map(code:string) => languageCodeToName(code),
  },
  {
    key: 'version',
    reverse: true,
  }
]));
— জোশুয়া হানসেন
সূত্র
2

মাল্টিপল কীগুলির সাহায্যে এটি করার একটি গতিশীল উপায়:

  • সাজানোর প্রতিটি কল / কী থেকে অনন্য মানগুলি ফিল্টার করুন
  • অর্ডার করা বা এটি বিপরীত
  • ইনডেক্সফ (মান) কী মানের উপর ভিত্তি করে প্রতিটি বস্তুর জন্য ওজন প্রস্থের জিরোপ্যাড যুক্ত করুন
  • অবরুদ্ধ ওজন ব্যবহার করে বাছাই করুন

এখানে চিত্র বর্ণনা লিখুন

Object.defineProperty(Array.prototype, 'orderBy', {
value: function(sorts) { 
    sorts.map(sort => {            
        sort.uniques = Array.from(
            new Set(this.map(obj => obj[sort.key]))
        );

        sort.uniques = sort.uniques.sort((a, b) => {
            if (typeof a == 'string') {
                return sort.inverse ? b.localeCompare(a) : a.localeCompare(b);
            }
            else if (typeof a == 'number') {
                return sort.inverse ? (a < b) : (a > b ? 1 : 0);
            }
            else if (typeof a == 'boolean') {
                let x = sort.inverse ? (a === b) ? 0 : a? -1 : 1 : (a === b) ? 0 : a? 1 : -1;
                return x;
            }
            return 0;
        });
    });

    const weightOfObject = (obj) => {
        let weight = "";
        sorts.map(sort => {
            let zeropad = `${sort.uniques.length}`.length;
            weight += sort.uniques.indexOf(obj[sort.key]).toString().padStart(zeropad, '0');
        });
        //obj.weight = weight; // if you need to see weights
        return weight;
    }

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

    return this;
}
});

ব্যবহার করুন:

// works with string, number and boolean
let sortered = your_array.orderBy([
    {key: "type", inverse: false}, 
    {key: "title", inverse: false},
    {key: "spot", inverse: false},
    {key: "internal", inverse: true}
]);

এখানে চিত্র বর্ণনা লিখুন

— লিওনার্দো ফিলিপ
সূত্র
1

@ স্নোবার্টের সমাধানের জেনেরিক সংস্করণটি এখানে রয়েছে:

var sortarray = [{field:'city', direction:'asc'}, {field:'price', direction:'desc'}];
array.sort(function(a,b){
    for(var i=0; i<sortarray.length; i++){
        retval = a[sortarray[i].field] < b[sortarray[i].field] ? -1 : a[sortarray[i].field] > b[sortarray[i].field] ? 1 : 0;
        if (sortarray[i].direction == "desc") {
            retval = retval * -1;
        }
        if (retval !== 0) {
            return retval;
        }
    }
}


})

এটি আমি ব্যবহার করছি এমন এক ধরণের রুটিনের উপর ভিত্তি করে। আমি এই নির্দিষ্ট কোডটি পরীক্ষা করিনি যাতে এতে ত্রুটি থাকতে পারে তবে আপনি ধারণাটি পেয়ে যান। ধারণাটি হ'ল প্রথম ক্ষেত্রের উপর ভিত্তি করে সাজানো যা কোনও পার্থক্য নির্দেশ করে এবং তারপরে থামিয়ে পরবর্তী রেকর্ডে যাবে। সুতরাং, আপনি যদি তিনটি ক্ষেত্র অনুসারে বাছাই করেন এবং তুলনাতে প্রথম ক্ষেত্রটি দুটি রেকর্ডের বাছাই করা ক্রম অনুসারে বাছাইয়ের জন্য যথেষ্ট হয় তবে সেই ফলাফলটি ফিরে আসুন এবং পরবর্তী রেকর্ডে যান।

আমি এটি 5000 টি রেকর্ডে (আসলে আরও জটিল জটিল সাজানোর যুক্তি দিয়ে) পরীক্ষা করেছি এবং এটি চোখের পলকের মধ্যে এটি করেছে। আপনি যদি ক্লায়েন্টের কাছে 1000 টিরও বেশি রেকর্ড লোড করে থাকেন তবে আপনার সম্ভবত সেভ-সাইড বাছাই এবং ফিল্টারিং ব্যবহার করা উচিত।

এই কোডটি কেস-সংবেদনশীলতা পরিচালনা করছে না তবে আমি এই তুচ্ছ পরিবর্তনটি হ্যান্ডেল করার জন্য পাঠকের কাছে রেখে দিই।

— HisDivineShadow
সূত্র
1

শোয়ার্জিয়ান ট্রান্সফর্ম আইডিয়মের উপর ভিত্তি করে আমার সমাধানটি এখানে আশা করি আপনি এটি দরকারী বলে আশা করি।

function sortByAttribute(array, ...attrs) {
  // generate an array of predicate-objects contains
  // property getter, and descending indicator
  let predicates = attrs.map(pred => {
    let descending = pred.charAt(0) === '-' ? -1 : 1;
    pred = pred.replace(/^-/, '');
    return {
      getter: o => o[pred],
      descend: descending
    };
  });
  // schwartzian transform idiom implementation. aka: "decorate-sort-undecorate"
  return array.map(item => {
    return {
      src: item,
      compareValues: predicates.map(predicate => predicate.getter(item))
    };
  })
  .sort((o1, o2) => {
    let i = -1, result = 0;
    while (++i < predicates.length) {
      if (o1.compareValues[i] < o2.compareValues[i]) result = -1;
      if (o1.compareValues[i] > o2.compareValues[i]) result = 1;
      if (result *= predicates[i].descend) break;
    }
    return result;
  })
  .map(item => item.src);
}

এটি কীভাবে ব্যবহার করবেন তা এখানে একটি উদাহরণ:

let games = [
  { name: 'Pako',              rating: 4.21 },
  { name: 'Hill Climb Racing', rating: 3.88 },
  { name: 'Angry Birds Space', rating: 3.88 },
  { name: 'Badland',           rating: 4.33 }
];

// sort by one attribute
console.log(sortByAttribute(games, 'name'));
// sort by mupltiple attributes
console.log(sortByAttribute(games, '-rating', 'name'));
— a8m
সূত্র
1
আমি এটিতে (এবং অন্যান্য পৃষ্ঠাগুলি) কয়েকটি জিনিস চেষ্টা করেছি। A8 মি দ্বারা এই সমাধানটি কেবল আমার পরিস্থিতির জন্য কাজ করেছিল: gist.github.com/cemerson/f1f1434286c1262b403f3d85c96688e0
— ক্রিস্টোফার ডি এমারসন
1

অন্য উপায়

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":"6",
     "city":"Dallas",
     "state":"TX",
     "zip":"75000",
     "price":"556699"},
    {"h_id":"5",
     "city":"New York",
     "state":"NY",
     "zip":"00010",
     "price":"962500"}
    ];
function sortBy(ar) {
  return ar.sort((a, b) => a.city === b.city ?
      b.price.toString().localeCompare(a.price) :
      a.city.toString().localeCompare(b.city));
}
console.log(sortBy(homes));
স্নিপেট প্রসারিত করুন

— mihai
সূত্র
0 
function sortMultiFields(prop){
    return function(a,b){
        for(i=0;i<prop.length;i++)
        {
            var reg = /^\d+$/;
            var x=1;
            var field1=prop[i];
            if(prop[i].indexOf("-")==0)
            {
                field1=prop[i].substr(1,prop[i].length);
                x=-x;
            }

            if(reg.test(a[field1]))
            {
                a[field1]=parseFloat(a[field1]);
                b[field1]=parseFloat(b[field1]);
            }
            if( a[field1] > b[field1])
                return x;
            else if(a[field1] < b[field1])
                return -x;
        }
    }
}

ক্ষেত্রের আগে কীভাবে (রাখুন - (বিয়োগ) সাইনটি ব্যবহার করতে হবে যদি আপনি নির্দিষ্ট ক্ষেত্রের উত্থানের ক্ষেত্রে বাছাই করতে চান)

homes.sort(sortMultiFields(["city","-price"]));

উপরের ফাংশনটি ব্যবহার করে আপনি একাধিক ক্ষেত্রের সাথে যে কোনও জসন অ্যারে বাছাই করতে পারেন। ফাংশন বডি মোটেও পরিবর্তন করার দরকার নেই

— নিখিল sHETH
সূত্র
0

@ ক্রিস্কেলির উত্তরটির অভিযোজন।

সর্বাধিক উত্তরগুলি অগ্রাহ্য করে যে মানটি দশ হাজারে এবং কম বা এক মিলিয়নের বেশি হলে দাম সঠিকভাবে বাছাই হবে না। জেএস হ'ল রেজোনান বর্ণমালা অনুসারে বাছাই করে। এটি এখানে বেশ ভাল উত্তর দেওয়া হয়েছিল, কেন জাভাস্ক্রিপ্ট "5, 10, 1" এবং এখানে পূর্ণসংখ্যার অ্যারে সঠিকভাবে বাছাই করতে পারে না কেন ।

ক্ষেত্র বা নোড বাছাই করা হয় এমন একটি সংখ্যা হলে শেষ পর্যন্ত আমাদের কিছু মূল্যায়ন করতে হবে। আমি বলছি না যে parseInt()এই ক্ষেত্রে ব্যবহার করা সঠিক উত্তর, সাজানো ফলাফল আরও গুরুত্বপূর্ণ।

var homes = [{
  "h_id": "2",
  "city": "Dallas",
  "state": "TX",
  "zip": "75201",
  "price": "62500"
}, {
  "h_id": "1",
  "city": "Dallas",
  "state": "TX",
  "zip": "75201",
  "price": "62510"
}, {
  "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": "6",
  "city": "Dallas",
  "state": "TX",
  "zip": "75000",
  "price": "556699"
}, {
  "h_id": "5",
  "city": "New York",
  "state": "NY",
  "zip": "00010",
  "price": "962500"
}];

homes.sort(fieldSorter(['price']));
// homes.sort(fieldSorter(['zip', '-state', 'price'])); // alternative

function fieldSorter(fields) {
  return function(a, b) {
    return fields
      .map(function(o) {
        var dir = 1;
        if (o[0] === '-') {
          dir = -1;
          o = o.substring(1);
        }
        if (!parseInt(a[o]) && !parseInt(b[o])) {
          if (a[o] > b[o]) return dir;
          if (a[o] < b[o]) return -(dir);
          return 0;
        } else {
          return dir > 0 ? a[o] - b[o] : b[o] - a[o];
        }
      })
      .reduce(function firstNonZeroValue(p, n) {
        return p ? p : n;
      }, 0);
  };
}
document.getElementById("output").innerHTML = '<pre>' + JSON.stringify(homes, null, '\t') + '</pre>';
<div id="output">

</div>
স্নিপেট প্রসারিত করুন

পরীক্ষা করার জন্য একটি মজার

— মার্ক কার্পেন্টার জুনিয়র
সূত্র
সমস্যাটি আপনি যে ডেটা বাছাই করার চেষ্টা করছেন তা নিয়ে। priceউদাহরণস্বরূপ স্ট্রিং ফর্ম্যাট হয়। আপনি যদি এটির উদাহরণ দিয়ে সঠিকভাবে কাজ করতে চান তবে ক্ষেত্রটি রূপান্তর করতে মানচিত্রটি ব্যবহার করুন আপনি প্রথমে নম্বর ফর্ম্যাট করতে চান। যেমনconst correctedHomes = homes.map(h => ({...h, price: +h.price}))
— খ্রিস্টীয়
0

বাহ, এখানে কিছু জটিল সমাধান রয়েছে। এত জটিল আমি সিদ্ধান্ত নিয়েছি সহজ কিছু, তবে বেশ শক্তিশালী কিছু নিয়ে আসব। এটা এখানে;

function sortByPriority(data, priorities) {
  if (priorities.length == 0) {
    return data;
  }

  const nextPriority = priorities[0];
  const remainingPriorities = priorities.slice(1);

  const matched = data.filter(item => item.hasOwnProperty(nextPriority));
  const remainingData = data.filter(item => !item.hasOwnProperty(nextPriority));

  return sortByPriority(matched, remainingPriorities)
    .sort((a, b) => (a[nextPriority] > b[nextPriority]) ? 1 : -1)
    .concat(sortByPriority(remainingData, remainingPriorities));
}

এবং আপনি এটি কীভাবে ব্যবহার করেন তার একটি উদাহরণ এখানে।

const data = [
  { id: 1,                         mediumPriority: 'bbb', lowestPriority: 'ggg' },
  { id: 2, highestPriority: 'bbb', mediumPriority: 'ccc', lowestPriority: 'ggg' },
  { id: 3,                         mediumPriority: 'aaa', lowestPriority: 'ggg' },
];

const priorities = [
  'highestPriority',
  'mediumPriority',
  'lowestPriority'
];


const sorted = sortByPriority(data, priorities);

এটি প্রথমে গুণাবলীর প্রাধান্য অনুসারে বাছাই করবে, তারপরে গুণাবলীর মান অনুসারে।

— Steztric
সূত্র
0

একাধিক ক্ষেত্র অনুসারে বাছাই করার একটি এক্সটেনসিবল উপায়।

homes.sort(function(left, right) {
    var city_order = left.city.localeCompare(right.city);
    var price_order = parseInt(left.price) - parseInt(right.price);
    return city_order || -price_order;
});

মন্তব্য

  • a.localeCompare(b)হয় সর্বজনীন সমর্থিত এবং আয় -1,0,1 যদি a<b, a==b, a>bযথাক্রমে।
  • বিয়োগফল সংখ্যাতে কাজ করে।
  • ||শেষ লাইনে cityঅগ্রাধিকার দেয় price।
  • যে কোনও ক্ষেত্রে, বিপরীতে অর্ডার নেগেগেট করুন -price_order
  • তারিখের তুলনা , সংখ্যারvar date_order = new Date(left.date) - new Date(right.date); মতো কাজ করে কারণ ১৯ date০ সাল থেকে তারিখ গণিতটি মিলি সেকেন্ডে পরিবর্তিত হয়।
  • অর-শৃঙ্খলে ক্ষেত্রগুলি যুক্ত করুন, return city_order || -price_order || date_order;
— বব স্টেইন
সূত্র
0

আমি মনে করি এটি এটি করার সবচেয়ে সহজ উপায় হতে পারে।

https://coderwall.com/p/ebqhca/javascript-sort-by-two-fields

এটি সত্যিই সহজ এবং আমি এটি 3 টি ভিন্ন মূল মান জোড় দিয়ে চেষ্টা করেছি এবং এটি দুর্দান্ত কাজ করেছে।

এখানে একটি সাধারণ উদাহরণ, আরও তথ্যের জন্য লিঙ্কটি দেখুন

testSort(data) {
    return data.sort(
        a['nameOne'] > b['nameOne'] ? 1
        : b['nameOne'] > a['nameOne'] ? -1 : 0 ||
        a['date'] > b['date'] ||
        a['number'] - b['number']
    );
}
— JDinar
সূত্র
0

আপনার উল্লেখের জন্য এখানে আমার উদাহরণ রয়েছে:

function msort(arr, ...compFns) {
  let fn = compFns[0];
  arr = [].concat(arr);
  let arr1 = [];
  while (arr.length > 0) {
    let arr2 = arr.splice(0, 1);
    for (let i = arr.length; i > 0;) {
      if (fn(arr2[0], arr[--i]) === 0) {
        arr2 = arr2.concat(arr.splice(i, 1));
      }
    }
    arr1.push(arr2);
  }

  arr1.sort(function (a, b) {
    return fn(a[0], b[0]);
  });

  compFns = compFns.slice(1);
  let res = [];
  arr1.map(a1 => {
    if (compFns.length > 0) a1 = msort(a1, ...compFns);
    a1.map(a2 => res.push(a2));
  });
  return res;
}

let tstArr = [{ id: 1, sex: 'o' }, { id: 2, sex: 'm' }, { id: 3, sex: 'm' }, { id: 4, sex: 'f' }, { id: 5, sex: 'm' }, { id: 6, sex: 'o' }, { id: 7, sex: 'f' }];

function tstFn1(a, b) {
  if (a.sex > b.sex) return 1;
  else if (a.sex < b.sex) return -1;
  return 0;
}

function tstFn2(a, b) {
  if (a.id > b.id) return -1;
  else if (a.id < b.id) return 1;
  return 0;
}

console.log(JSON.stringify(msort(tstArr, tstFn1, tstFn2)));
//output:
//[{"id":7,"sex":"f"},{"id":4,"sex":"f"},{"id":5,"sex":"m"},{"id":3,"sex":"m"},{"id":2,"sex":"m"},{"id":6,"sex":"o"},{"id":1,"sex":"o"}]
— জিপার
সূত্র
0

আমি অনুরূপ কিছু খুঁজছিলাম এবং এটি দিয়ে শেষ:

প্রথমে আমাদের এক বা একাধিক বাছাই কার্য রয়েছে, সর্বদা 0, 1 বা -1 হয়:

const sortByTitle = (a, b): number => 
  a.title === b.title ? 0 : a.title > b.title ? 1 : -1;

আপনি বাছাই করতে চান একে অপরের সম্পত্তি জন্য আরও ফাংশন তৈরি করতে পারেন।

তারপরে আমার একটি ফাংশন রয়েছে যা এই বাছাই করা ফাংশনগুলিকে এক সাথে সংযুক্ত করে:

const createSorter = (...sorters) => (a, b) =>
  sorters.reduce(
    (d, fn) => (d === 0 ? fn(a, b) : d),
    0
  );

এটি পাঠ্যযোগ্য উপায়ে উপরের বাছাইয়ের ক্রিয়াগুলি একত্রিত করতে ব্যবহার করা যেতে পারে:

const sorter = createSorter(sortByTitle, sortByYear)

items.sort(sorter)

যখন একটি বাছাই ফাংশন 0 ফিরে আসে পরবর্তী বাছাই ফাংশনটি আরও বাছাইয়ের জন্য ডাকা হবে।

— Soesah
সূত্র
0

ঠিক অন্য একটি বিকল্প। নিম্নলিখিত ইউটিলিটি ফাংশনটি ব্যবহার করতে বিবেচনা করুন:

/** Performs comparing of two items by specified properties
 * @param  {Array} props for sorting ['name'], ['value', 'city'], ['-date']
 * to set descending order on object property just add '-' at the begining of property
 */
export const compareBy = (...props) => (a, b) => {
  for (let i = 0; i < props.length; i++) {
    const ascValue = props[i].startsWith('-') ? -1 : 1;
    const prop = props[i].startsWith('-') ? props[i].substr(1) : props[i];
    if (a[prop] !== b[prop]) {
      return a[prop] > b[prop] ? ascValue : -ascValue;
    }
  }
  return 0;
};

ব্যবহারের উদাহরণ (আপনার ক্ষেত্রে):

homes.sort(compareBy('city', '-price'));

এটি লক্ষ্য করা উচিত যে এই ঠিকানাটি 'অ্যাড্রেস.সিটি' বা 'স্টাইল.সাইজ.উইথথ' ইত্যাদির মতো নেস্টেড বৈশিষ্ট্যগুলি ব্যবহার করতে সক্ষম হতে আরও সাধারণীকরণ করা যেতে পারে

— দিমিত্রি আঁচ
সূত্র
0

তুলনার আগে মানগুলি বিন্যাস করার সুযোগ পেয়ে একাধিক ক্ষেত্র অনুসারে বাছাই করার জন্য এটি একটি পুনরাবৃত্ত আলগোরিদিম।

var data = [
{
    "id": 1,
    "ship": null,
    "product": "Orange",
    "quantity": 7,
    "price": 92.08,
    "discount": 0
},
{
    "id": 2,
    "ship": "2017-06-14T23:00:00.000Z".toDate(),
    "product": "Apple",
    "quantity": 22,
    "price": 184.16,
    "discount": 0
},
...
]
var sorts = ["product", "quantity", "ship"]

// comp_val formats values and protects against comparing nulls/undefines
// type() just returns the variable constructor
// String.lower just converts the string to lowercase.
// String.toDate custom fn to convert strings to Date
function comp_val(value){
    if (value==null || value==undefined) return null
    var cls = type(value)
    switch (cls){
        case String:
            return value.lower()
    }
    return value
}

function compare(a, b, i){
    i = i || 0
    var prop = sorts[i]
    var va = comp_val(a[prop])
    var vb = comp_val(b[prop])

    // handle what to do when both or any values are null
    if (va == null || vb == null) return true

    if ((i < sorts.length-1) && (va == vb)) {
        return compare(a, b, i+1)
    } 
    return va > vb
}

var d = data.sort(compare);
console.log(d);

যদি a এবং b সমান হয় তবে এটি কোনওটি উপলব্ধ না হওয়া অবধি পরবর্তী ক্ষেত্রটি চেষ্টা করবে।

— Mackraken
সূত্র
-1 
homes.sort(function(a,b) { return a.city - b.city } );
homes.sort(function(a,b){
    if (a.city==b.city){
        return parseFloat(b.price) - parseFloat(a.price);
    } else {
        return 0;
    }
});
— জোনান পাইনেদা
সূত্র
কেন শুধু সব কিছু একক ফাংশনে রাখা হয়নি? যদি শহর সমান না হয় তবে তারগুলির পার্থক্যটি ফিরিয়ে দিন, অন্যথায়, দামের চেয়ে আলাদা করুন।
— ম্যাড পদার্থবিদ
-1

এখানে 'অ্যাফিলিয়েটডিউডেট' এবং 'শিরোনাম' কলাম রয়েছে, উভয়ই ক্রমবর্ধমান ক্রমে সাজানো হয়েছে।

array.sort(function(a, b) {

               if (a.AffiliateDueDate > b.AffiliateDueDate ) return 1;
               else if (a.AffiliateDueDate < b.AffiliateDueDate ) return -1;
               else if (a.Title > b.Title ) return 1;
               else if (a.Title < b.Title ) return -1;
               else return 0;
             })
— আমায় কুলকারনী
সূত্র
-1

দুটি তারিখের ক্ষেত্র এবং একটি সংখ্যার ক্ষেত্র উদাহরণে বাছাই করা:

var generic_date =  new Date(2070, 1, 1);
checkDate = function(date) {
  return Date.parse(date) ? new Date(date): generic_date;
}

function sortData() {  
  data.sort(function(a,b){
    var deltaEnd = checkDate(b.end) - checkDate(a.end);
    if(deltaEnd) return deltaEnd;

    var deltaRank = a.rank - b.rank;
    if (deltaRank) return deltaRank;

    var deltaStart = checkDate(b.start) - checkDate(a.start);
    if(deltaStart) return deltaStart;

    return 0;
  });
}

http://jsfiddle.net/hcWgf/57/

— ইগর ভাসচুক
সূত্র
-1 
function sort(data, orderBy) {
        orderBy = Array.isArray(orderBy) ? orderBy : [orderBy];
        return data.sort((a, b) => {
            for (let i = 0, size = orderBy.length; i < size; i++) {
                const key = Object.keys(orderBy[i])[0],
                    o = orderBy[i][key],
                    valueA = a[key],
                    valueB = b[key];
                if (!(valueA || valueB)) {
                    console.error("the objects from the data passed does not have the key '" + key + "' passed on sort!");
                    return [];
                }
                if (+valueA === +valueA) {
                    return o.toLowerCase() === 'desc' ? valueB - valueA : valueA - valueB;
                } else {
                    if (valueA.localeCompare(valueB) > 0) {
                        return o.toLowerCase() === 'desc' ? -1 : 1;
                    } else if (valueA.localeCompare(valueB) < 0) {
                        return o.toLowerCase() === 'desc' ? 1 : -1;
                    }
                }
            }
        });
    }

ব্যবহার :

sort(homes, [{city : 'asc'}, {price: 'desc'}])

কোড স্নিপেট দেখান

— ইলিয়াস পিনহেরো
সূত্র
-1

এই সহজ সমাধান সম্পর্কে: 

const sortCompareByCityPrice = (a, b) => {
    let comparison = 0
    // sort by first criteria
    if (a.city > b.city) {
        comparison = 1
    }
    else if (a.city < b.city) {
        comparison = -1
    }
    // If still 0 then sort by second criteria descending
    if (comparison === 0) {
        if (parseInt(a.price) > parseInt(b.price)) {
            comparison = -1
        }
        else if (parseInt(a.price) < parseInt(b.price)) {
            comparison = 1
        }
    }
    return comparison 
}

এই প্রশ্নের ভিত্তিতে জাভাস্ক্রিপ্টকে একাধিক (সংখ্যা) ক্ষেত্রগুলি অনুসারে সাজান

— ramvanet
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.