grouperArray.sort(function (a, b) {
var aSize = a.gsize;
var bSize = b.gsize;
var aLow = a.glow;
var bLow = b.glow;
console.log(aLow + " | " + bLow);
return (aSize < bSize) ? -1 : (aSize > bSize) ? 1 : 0;
});
সুতরাং উপরের কোডটি জিএসাইজের মাধ্যমে অ্যারে বাছাই করে - ক্ষুদ্র থেকে বৃহত্তম। এটি ভাল কাজ করে। তবে জিএসইজটি যদি একই হয় তবে আমি এটি গ্লো অনুসারে বাছাই করতে চাই।
ধন্যবাদ
উত্তর:
grouperArray.sort(function (a, b) {
var aSize = a.gsize;
var bSize = b.gsize;
var aLow = a.glow;
var bLow = b.glow;
console.log(aLow + " | " + bLow);
if(aSize == bSize)
{
return (aLow < bLow) ? -1 : (aLow > bLow) ? 1 : 0;
}
else
{
return (aSize < bSize) ? -1 : 1;
}
});
grouperArray.sort((a, b) => a.gsize == b.gsize ? a.glow - b.glow : a.gsize - b.gsize। কোডটি বোঝা সহজ করার জন্য, আমরা এর জন্য পরীক্ষাটি পরিষ্কারভাবে রাখি ==।
grouperArray.sort(function (a, b) {
return a.gsize - b.gsize || a.glow - b.glow;
});
সংক্ষিপ্ত সংস্করণ
sort an array with a key's value firstএবং তার পরে কাজ করেছিলsort the result with another key's value
grouperArray.sort((a, b) => a.gsize - b.gsize || a.glow - b.glow);
এমনকি তীর সিনট্যাক্স ব্যবহার করে আরও ছোট সংস্করণ!
grouperArray.sort((a,b)=>a.gsize-b.gsize||a.glow-b.glow);
আমি বুঝতে পারি যে এটি সম্পর্কে কিছু আগে জিজ্ঞাসা করা হয়েছিল, তবে আমি ভেবেছিলাম যে আমি আমার সমাধান যুক্ত করব।
এই ফাংশনটি গতিশীলভাবে সাজানোর পদ্ধতিগুলি উত্পন্ন করে। আরোহী বা অবতরণ ক্রম নির্দেশ করতে কেবল প্রতিটি বাছাইযোগ্য বাচ্চার সম্পত্তির নাম সরবরাহ করুন + সুপারটি পুনরায় ব্যবহারযোগ্য এবং আপনার একসাথে রাখা ডেটা কাঠামো সম্পর্কে কিছু জানা দরকার নেই। বোকা প্রমাণ করা যেতে পারে - তবে এটি প্রয়োজনীয় বলে মনে হচ্ছে না।
function getSortMethod(){
var _args = Array.prototype.slice.call(arguments);
return function(a, b){
for(var x in _args){
var ax = a[_args[x].substring(1)];
var bx = b[_args[x].substring(1)];
var cx;
ax = typeof ax == "string" ? ax.toLowerCase() : ax / 1;
bx = typeof bx == "string" ? bx.toLowerCase() : bx / 1;
if(_args[x].substring(0,1) == "-"){cx = ax; ax = bx; bx = cx;}
if(ax != bx){return ax < bx ? -1 : 1;}
}
}
}
উদাহরণস্বরূপ ব্যবহার:
আইটেম.সোর্ট (getSortMethod ('- দাম', '+ অগ্রাধিকার', '+ নাম'));
এটি itemsসর্বনিম্নের সাথে বাছাই করবে price, সর্বাধিকের সাথে আইটেমটিতে যাওয়ার ক্ষেত্রে priority। আরও বন্ধন আইটেম দ্বারা নষ্ট হয়ে গেছেname
আইটেমগুলি যেমন অ্যারের মতো হয়:
var items = [
{ name: "z - test item", price: "99.99", priority: 0, reviews: 309, rating: 2 },
{ name: "z - test item", price: "1.99", priority: 0, reviews: 11, rating: 0.5 },
{ name: "y - test item", price: "99.99", priority: 1, reviews: 99, rating: 1 },
{ name: "y - test item", price: "0", priority: 1, reviews: 394, rating: 3.5 },
{ name: "x - test item", price: "0", priority: 2, reviews: 249, rating: 0.5 } ...
];
লাইভ ডেমো: http://gregtaff.com/misc/mult_field_sort/
সম্পাদনা: ক্রোম সহ স্থির সমস্যা।
error TS2554: Expected 0 arguments, but got ..:) এখানে সিনট্যাক্স ব্যবহার stackoverflow.com/a/4116634/5287221
আমি আশা করি আপনি তিনটি অপারেটর ((aSize < bSize) ? -1 : (aSize > bSize) ? 1 : 0;)বিভ্রান্ত হয়েছে। আরও ভালভাবে বুঝতে আপনার লিঙ্কটি চেক আউট করা উচিত।
ততক্ষণে, এখানে / আপনার কোডটি সম্পূর্ণরূপে ফুরিয়েছে।
grouperArray.sort(function (a, b) {
if (a.gsize < b.gsize)
{
return -1;
}
else if (a.gsize > b.gsize)
{
return 1;
}
else
{
if (a.glow < b.glow)
{
return -1;
}
else if (a.glow > b.glow)
{
return 1;
}
return 0;
}
});
যারা আরও কিছু জেনেরিক চান যা কোনও সংখ্যক ক্ষেত্রের সাথে কাজ করতে পারে তাদের জন্য এখানে একটি বাস্তবায়ন।
Array.prototype.sortBy = function (propertyName, sortDirection) {
var sortArguments = arguments;
this.sort(function (objA, objB) {
var result = 0;
for (var argIndex = 0; argIndex < sortArguments.length && result === 0; argIndex += 2) {
var propertyName = sortArguments[argIndex];
result = (objA[propertyName] < objB[propertyName]) ? -1 : (objA[propertyName] > objB[propertyName]) ? 1 : 0;
//Reverse if sort order is false (DESC)
result *= !sortArguments[argIndex + 1] ? 1 : -1;
}
return result;
});
}
মূলত, আপনি যে কোনও সংখ্যার সম্পত্তি নাম / সাজানোর দিকনির্দেশ নির্দিষ্ট করতে পারেন:
var arr = [{
LastName: "Doe",
FirstName: "John",
Age: 28
}, {
LastName: "Doe",
FirstName: "Jane",
Age: 28
}, {
LastName: "Foo",
FirstName: "John",
Age: 30
}];
arr.sortBy("LastName", true, "FirstName", true, "Age", false);
//Will return Jane Doe / John Doe / John Foo
arr.sortBy("Age", false, "LastName", true, "FirstName", false);
//Will return John Foo / John Doe / Jane Doe
grouperArray.sort(function (a, b) {
var aSize = a.gsize;
var bSize = b.gsize;
var aLow = a.glow;
var bLow = b.glow;
console.log(aLow + " | " + bLow);
return (aSize < bSize) ? -1 : (aSize > bSize) ? 1 : (aLow < bLow) ? -1 : (aLow > bLow) ? 1 : 0); });
এখানে এমন একটি বাস্তবায়ন যা 1 থেকে অসীমের জন্য সর্বাধিক সংখ্যক বাছাই করা ক্ষেত্রকে বাছাই করতে পুনরাবৃত্তি ব্যবহার করে। আপনি এটি একটি ফলাফল অ্যারে যা ফলাফল সাজানোর জন্য ফলাফল অবজেক্টগুলির একটি অ্যারে এবং একটি প্রকার অ্যারে যা বাছাইকরণ সংজ্ঞায়িত বাছাই করা অবজেক্টগুলির একটি অ্যারে পাস করেন। প্রতিটি বাছাই করা অবজেক্টের চাবি নামের অনুসারে বাছাই করা নামটির জন্য একটি "নির্বাচন" কী এবং একটি "ক্রম" কী থাকা আবশ্যক যা একটি স্ট্রিং যা "আরোহী" বা "অবতরণ" নির্দেশ করে।
sortMultiCompare = (a, b, sorts) => {
let select = sorts[0].select
let order = sorts[0].order
if (a[select] < b[select]) {
return order == 'ascending' ? -1 : 1
}
if (a[select] > b[select]) {
return order == 'ascending' ? 1 : -1
}
if(sorts.length > 1) {
let remainingSorts = sorts.slice(1)
return this.sortMultiCompare(a, b, remainingSorts)
}
return 0
}
sortResults = (results, sorts) => {
return results.sort((a, b) => {
return this.sortMultiCompare(a, b, sorts)
})
}
// example inputs
const results = [
{
"LastName": "Doe",
"FirstName": "John",
"MiddleName": "Bill"
},
{
"LastName": "Doe",
"FirstName": "Jane",
"MiddleName": "Bill"
},
{
"LastName": "Johnson",
"FirstName": "Kevin",
"MiddleName": "Bill"
}
]
const sorts = [
{
"select": "LastName",
"order": "ascending"
},
{
"select": "FirstName",
"order": "ascending"
},
{
"select": "MiddleName",
"order": "ascending"
}
]
// call the function like this:
let sortedResults = sortResults(results, sorts)
মাল্টিপল কীগুলির সাহায্যে এটি করার একটি গতিশীল উপায়:
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}
]);
এটিই আমি ব্যবহার করি
function sort(a, b) {
var _a = "".concat(a.size, a.glow);
var _b = "".concat(b.size, b.glow);
return _a < _b;
}
দুটি আইটেমকে স্ট্রিং হিসাবে কনক্যাট করুন এবং সেগুলি স্ট্রিংয়ের মান অনুসারে বাছাই করা হবে। যদি আপনি চান আপনি _a এবং _b কে পার্সে মুড়ে রাখতে পারেন তবে তাদের সংখ্যার সাথে তুলনা করতে যদি আপনি জানেন যে তারা সংখ্যার হবে।
মামলার সমাধান এখানে আপনার যখন অগ্রাধিকার অনুসারে বাছাই কী থাকে যা কিছু নির্দিষ্ট আইটেমের মধ্যে নাও থাকতে পারে, তাই আপনাকে ফলব্যাক কী অনুসারে বাছাই করতে হবে।
একটি ইনপুট ডেটা উদাহরণ ( আইডি 2 অগ্রাধিকার বাছাই কী):
const arr = [
{id: 1},
{id: 2, id2: 3},
{id: 4},
{id: 3},
{id: 10, id2: 2},
{id: 7},
{id: 6, id2: 1},
{id: 5},
{id: 9, id2: 2},
{id: 8},
];
এবং আউটপুটটি হওয়া উচিত:
[ { id: 6, id2: 1 },
{ id: 9, id2: 2 },
{ id: 10, id2: 2 },
{ id: 2, id2: 3 },
{ id: 1 },
{ id: 3 },
{ id: 4 },
{ id: 5 },
{ id: 7 },
{ id: 8 } ]
তুলনামূলক ফাংশনটি হবে:
arr.sort((a,b) => {
if(a.id2 || b.id2) {
if(a.id2 && b.id2) {
if(a.id2 === b.id2) {
return a.id - b.id;
}
return a.id2 - b.id2;
}
return a.id2 ? -1 : 1;
}
return a.id - b.id
});
দ্রষ্টব্য ক্ষেত্রে যদি .id এর .id2 শূন্য হতে পারে, ব্যবহার করা বিবেচনা typeof।
আমার ক্ষেত্রে, আমি পরম 'গুরুত্বপূর্ণ' এবং 'তারিখ' অনুসারে বিজ্ঞপ্তি তালিকাটি বাছাই করি
পদক্ষেপ 1: আমি 'গুরুত্বপূর্ণ' এবং গুরুত্বহীন দ্বারা বিজ্ঞপ্তিগুলি ফিল্টার করি
let importantNotifications = notifications.filter(
(notification) => notification.isImportant);
let unImportantNotifications = notifications.filter(
(notification) => !notification.isImportant);
পদক্ষেপ 2: আমি তাদের তারিখ অনুসারে বাছাই করি
sortByDate = (notifications) => {
return notifications.sort((notificationOne, notificationTwo) => {
return notificationOne.date - notificationTwo.date;
});
};
পদক্ষেপ 3: এগুলি মার্জ করুন
[
...this.sortByDate(importantNotifications),
...this.sortByDate(unImportantNotifications),
];