Javascript 如何对对象数组和数组子集进行排序

模式

var my_array = [ 
{
    "title": "a",
    "pinned": {
        "status": "true",
        "order": "1"
    }
},
{
    "title": "d",
    "pinned": {
        "status": "false",
        "order": "n/a"
    }
},
{
    "title": "c",
    "pinned": {
        "status": "true",
        "order": "0"
    }
},
{
    "title": "b",
    "pinned": {
        "status": "false",
        "order": "n/a"
    }
}
];

期望的行为

按

标题

字母顺序对对象进行排序，
除非它们的

固定状态为
true
，

在这种情况下，将此项的“子集”移动到数组的开头，

按其
固定顺序排序。顺序
值

一个示例场景是一个论坛，它的帖子按日期排序，但顶部也有粘性帖子，这些帖子按定义的顺序排序

因此，原始模式将显示为：

[ 
{// i am at the top, because i have a pinned status of true and order of 0  
    "title": "c",
    "pinned": {
        "status": "true",
        "order": "0"
    }
},
{// i am second from the top, because i have a pinned status of true and order of 1  
    "title": "a",
    "pinned": {
        "status": "true",
        "order": "1"
    }
},
{// i follow in alphabetical order 
    "title": "b",
    "pinned": {
        "status": "false",
        "order": "n/a"
    }
},
{// i follow in alphabetical order 
    "title": "d",
    "pinned": {
        "status": "false",
        "order": "n/a"
    }
}
]

我尝试过的

my_array.sort(function(a, b) {
    return a.pinned.order.localeCompare(b.pinned.order) || a.title.localeCompare(b.title);
});

根据这一回答：


我也试过…

我曾考虑根据pinted.status的值创建两个单独的数组，分别对它们进行排序，然后重新组合它们（如下所示），但我想知道是否还有更优雅的东西

var my_array = [ 
{
    "title": "a",
    "pinned": {
        "status": "true",
        "order": "1"
    }
},
{
    "title": "d",
    "pinned": {
        "status": "false",
        "order": "n/a"
    }
},
{
    "title": "c",
    "pinned": {
        "status": "true",
        "order": "0"
    }
},
{
    "title": "b",
    "pinned": {
        "status": "false",
        "order": "n/a"
    }
}
];


var my_subset = [];

for (var i = 0; i < my_array.length; i++) {

    if (my_array[i].pinned.status === "true") {
        // add to subset
        my_subset.push(my_array[i]);
        // remove from original array
        my_array.splice(i, 1);
    }

}

// sort "pruned" original array alphabetically
my_array.sort(function(a, b) {
    return a.title.localeCompare(b.title);
});

// sort subset array by pinned.order
my_subset.sort(function(a, b) {
    return a.pinned.order.localeCompare(b.pinned.order, undefined, { numeric: true });
});

// prepend subset to original array
var new_array = my_subset.concat(my_array);

// array is sorted as desired
console.log(new_array);

var my_数组=[
{
“标题”：“a”，
“钉住”：{
“状态”：“正确”，
“订单”：“1”
}
},
{
“标题”：“d”，
“钉住”：{
“状态”：“错误”，
“订单”：“不适用”
}
},
{
“标题”：“c”，
“钉住”：{
“状态”：“正确”，
“订单”：“0”
}
},
{
“标题”：“b”，
“钉住”：{
“状态”：“错误”，
“订单”：“不适用”
}
}
];
var my_子集=[]；
对于（var i=0；i
首先通过将数字字符串设置为数字，将布尔字符串设置为布尔值来修复数据：

for (const item of my_array) {
    item.pinned.status = JSON.parse(item.pinned.status);
    item.pinned.order = Number(item.pinned.order);
}

现在，您不必将它们作为字符串进行比较。否则，您的方法基本上是好的，您只是忘记了一个最重要的指标，即项目是否应该到达顶部：它的
被钉住了。status
。按第一个进行比较，以便任何固定的项目位于任何未固定的项目之前

my_array.sort(function(a, b) {
    return -(a.pinned.status - b.pinned.status) // reverse: true before false
    || (a.pinned.status // equal to b.pinned.status
      ? a.pinned.order - b.pinned.order
      : a.title.localeCompare(b.title));
});


var my\u数组=[{
“标题”：“a”，
“钉住”：{
“状态”：正确，
“订单”：1
}
},
{
“标题”：“d”，
“钉住”：{
“状态”：假，
“订单”：0
}
},
{
“标题”：“c”，
“钉住”：{
“状态”：正确，
“订单”：0
}
},
{
“标题”：“b”，
“钉住”：{
“状态”：假，
“订单”：0
}
}
];
my_array.sort（函数（a，b）{
return-（a.pinted.status-b.pinted.status）//反向：false之前为true
||
（a.pinted.status//等于b.pinted.status
?
a、 pinted.order-b.pinted.order：
a、 标题。本地比较（b.标题））；
});
log（我的_数组）首先通过将数字字符串设置为数字，将布尔字符串设置为布尔值来修复数据：

for (const item of my_array) {
    item.pinned.status = JSON.parse(item.pinned.status);
    item.pinned.order = Number(item.pinned.order);
}

现在，您不必将它们作为字符串进行比较。否则，您的方法基本上是好的，您只是忘记了一个最重要的指标，即项目是否应该到达顶部：它的
被钉住了。status
。按第一个进行比较，以便任何固定的项目位于任何未固定的项目之前

my_array.sort(function(a, b) {
    return -(a.pinned.status - b.pinned.status) // reverse: true before false
    || (a.pinned.status // equal to b.pinned.status
      ? a.pinned.order - b.pinned.order
      : a.title.localeCompare(b.title));
});


var my\u数组=[{
“标题”：“a”，
“钉住”：{
“状态”：正确，
“订单”：1
}
},
{
“标题”：“d”，
“钉住”：{
“状态”：假，
“订单”：0
}
},
{
“标题”：“c”，
“钉住”：{
“状态”：正确，
“订单”：0
}
},
{
“标题”：“b”，
“钉住”：{
“状态”：假，
“订单”：0
}
}
];
my_array.sort（函数（a，b）{
return-（a.pinted.status-b.pinted.status）//反向：false之前为true
||
（a.pinted.status//等于b.pinted.status
?
a、 pinted.order-b.pinted.order：
a、 标题。本地比较（b.标题））；
});
log（我的_数组）如果可以使用Lodash（Javascript实用程序库），则可以使用orderBy或sortBy：

在项目中使用Lodash：

<script src="lodash.js"></script>

如果可以使用Lodash（Javascript实用程序库），则可以使用orderBy或sortBy：

在项目中使用Lodash：

<script src="lodash.js"></script>

试试这个：

my_array.sort(function(a, b) {
    return a.title.localeCompare(b.title);
}).sort(function(a, b) {
    return a.pinned.order.localeCompare(b.pinned.order)
});

试试这个：

my_array.sort(function(a, b) {
    return a.title.localeCompare(b.title);
}).sort(function(a, b) {
    return a.pinned.order.localeCompare(b.pinned.order)
});

好了：


var my_数组=[
{
“标题”：“a”，
“钉住”：{
“状态”：“正确”，
“订单”：“1”
}
},
{
“标题”：“d”，
“钉住”：{
“状态”：“错误”，
“订单”：“不适用”
}
},
{
“标题”：“c”，
“钉住”：{
“状态”：“正确”，
“订单”：“0”
}
},
{
“标题”：“b”，
“钉住”：{
“状态”：“错误”，
“订单”：“不适用”
}
}
];
var-trueArr=[]；
var falseArr=[]；
var titlear=[]；
var tempArr=[]
for（my_数组的var obj）{
如果（obj.pinted.status==“true”）{
真方位推力（obj）；
}否则{
假方位推力（obj）；
}
}
功能排序器（arr）{
Titlear=[]；
tempArr=[]；
用于（arr的var obj）{
标题器推送（对象标题）；
}
titleArr=titleArr.sort（）；
用于（变量计数器=0；计数器就这样：


var my_数组=[
{
“标题”：“a”，
“钉住”：{
“状态”：“正确”，
“订单”：“1”
}
},
{
“标题”：“d”，
“钉住”：{
“状态”：“错误”，
“订单”：“不适用”
}
},
{
“标题”：“c”，
“钉住”：{
“状态”：“正确”，
“订单”：“0”