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(function (a,b) {
return 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;}
}
}
}
用法示例:
items.sort(getSortMethod(\'-price \',\'+ priority \',\'+ name \'));;
这将首先以最低的
price
排序
items
,并以最高的ѭ7item排序。
name
打破了其他纽带
项目是一个数组,如:
var items = [
{ name: \"z - test item\",price: \"99.99\",priority: 0,reviews: 309,rating: 2 },{ name: \"z - test item\",price: \"1.99\",reviews: 11,rating: 0.5 },{ name: \"y - test item\",priority: 1,reviews: 99,rating: 1 },price: \"0\",reviews: 394,rating: 3.5 },{ name: \"x - test item\",priority: 2,reviews: 249,rating: 0.5 } ...
];
现场演示:http://gregtaff.com/misc/multi_field_sort/
编辑:修复了Chrome的问题。
,我希望三元运算符
((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\",{
LastName: \"Foo\",Age: 30
}];
arr.sortBy(\"LastName\",true,\"FirstName\",\"Age\",false);
//Will return Jane Doe / John Doe / John Foo
arr.sortBy(\"Age\",false,\"LastName\",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 );
});
,
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到无限的任意数量的排序字段进行排序的实现。您将结果数组(它是要排序的结果对象的数组)和结果数组(它是定义排序的排序对象的数组)传递给它。每个排序对象必须具有一个用于排序的键名称的“ select”键和一个“ order”键,该键是一个表示“升序”或“降序”的字符串。
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,remainingSorts)
}
return 0
}
sortResults = (results,sorts) => {
return results.sort((a,b) => {
return this.sortMultiCompare(a,sorts)
})
}
// example inputs
const results = [
{
\"LastName\": \"Doe\",\"FirstName\": \"John\",\"MiddleName\": \"Bill\"
},{
\"LastName\": \"Doe\",\"FirstName\": \"Jane\",{
\"LastName\": \"Johnson\",\"FirstName\": \"Kevin\",\"MiddleName\": \"Bill\"
}
]
const sorts = [
{
\"select\": \"LastName\",\"order\": \"ascending\"
},{
\"select\": \"FirstName\",{
\"select\": \"MiddleName\",\"order\": \"ascending\"
}
]
// call the function like this:
let sortedResults = sortResults(results,sorts)
,当您具有优先级排序键(某些特定项目中可能不存在)时,这是这种情况的解决方案,因此您必须按备用键进行排序。
输入数据示例(id2是优先级排序键):
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,{id: 8},];
输出应为:
[ { id: 6,id2: 1 },{ id: 9,id2: 2 },{ id: 10,{ 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
});
附言如果.id2的.id可以为零,请考虑使用
typeof
。
,
grouperArray.sort(
function(a,b){return a.gsize == b.gsize ? a.glow - b.glow : a.gsize - b.gsize}
);
,
grouperArray.sort(function (a,b) {
var aSize = a.gsize;
var bSize = b.gsize;
if (aSize !== aSize)
return aSize - bSize;
return a.glow - b.glow;
});
尚未测试,但我认为应该可以。
,这就是我用的
function sort(a,b) {
var _a = \"\".concat(a.size,a.glow);
var _b = \"\".concat(b.size,b.glow);
return _a < _b;
}
将这两个项目组合为字符串,然后将它们按字符串值排序。如果您愿意,可以将_a和_b与parseInt进行包装,以在它们知道是数字的情况下将它们作为数字进行比较。