Question

我有两个数组。

itemsArray = 
[
{ id: 8, name: 'o'},
{ id: 7, name: 'g'},
{ id: 6, name: 'a'},
{ id: 5, name: 'k'},
{ id: 4, name: 'c'}
]

sortArray = [4,5]

我该如何按sortArray（lodash或pure）对itemsArray进行排序，但是我要这样做：

newArray = 
[
{ id: 4, name: 'c'},
{ id: 5, name: 'k'},
{ id: 8, name: 'o'},
{ id: 7, name: 'g'},
{ id: 6, name: 'a'}
]

Answer 1

在这种情况下，您想在多个级别上进行排序，则需要在排序函数中按重要性的降序对其进行排序。

在这种情况下，我们会定期对两个元素都位于或不在排序数组中的情况进行排序。

var itemsArray = [
    { id: 8, name: 'o' },
    { id: 7, name: 'g' },
    { id: 6, name: 'a' },
    { id: 5, name: 'k' },
    { id: 4, name: 'c' }
];
var sortArray = [4, 5];
var sortedItemsArray = itemsArray.sort(function (a, b) {
    if (sortArray.includes(a.id) == sortArray.includes(b.id)) { //both or neither are in sort array
        return b.id - a.id;
    }
    else if (sortArray.includes(a.id)) { //only a in sort array
        return -1;
    }
    else { //only b in sort array
        return 1;
    }
});
console.log(sortedItemsArray);

以上代码段可以通过多种方式扩展，但是一种流行的方法是将其分为几个排序步骤。

var itemsArray = [
    { id: 8, name: 'o' },
    { id: 7, name: 'g' },
    { id: 6, name: 'a' },
    { id: 5, name: 'k' },
    { id: 4, name: 'c' }
];
var sortArray = [4, 5];
function sortId(a, b) {
    return b.id - a.id;
}
function sortIdByList(a, b) {
    if (sortArray.includes(a.id)) {
        return -1;
    }
    if (sortArray.includes(b.id)) {
        return 1;
    }
    return 0;
}
//TEST
var sortedItemsArray = itemsArray
    .sort(sortId)
    .sort(sortIdByList);
console.log(sortedItemsArray);

此模式可以更容易维护，因为每个步骤都经过清晰标记，并且可以在其他排序情况下重用这些功能。

此模式的唯一缺点是您最终要遍历列表多次，从而增加了排序时间。通常这不是问题，但在很大的列表中，这可能很重要。

仅按数组索引排序

正如评论所指出的那样，我误解了问题，因此前两个排序片段不一定能提供理想的结果。

此版本仅按排序数组中的id索引进行排序：

var itemsArray = [
    { id: 8, name: 'o' },
    { id: 7, name: 'g' },
    { id: 6, name: 'a' },
    { id: 5, name: 'k' },
    { id: 4, name: 'c' }
];
var sortArray = [4, 5];
//TEST
var sortedItemsArray = itemsArray
    .sort(function (a, b) {
    //Calculate index value of a
    var A = sortArray.indexOf(a.id);
    if (A == -1) {
        A = sortArray.length;
    }
    //Calculate index value of b
    var B = sortArray.indexOf(b.id);
    if (B == -1) {
        B = sortArray.length;
    }
    //Return comparison
    return A - B;
});
console.log(sortedItemsArray);

Answer 2

您可以采用数组的索引来保持相对位置，并采用负索引的特殊项目在顶部进行排序。

然后通过获取索引对数组进行排序。

var array = [{ id: 8, name: 'o' }, { id: 7, name: 'g' }, { id: 6, name: 'a' }, { id: 5, name: 'k' }, { id: 4, name: 'c' }],
    sortArray = [4, 5],
    indices = array.reduce((r, { id }, i) => (r[id] = i, r), {});
    
sortArray.forEach((id, i, { length }) => indices[id] = i - length);

array.sort(({ id: a }, { id: b }) => indices[a] - indices[b]);

console.log(array);
console.log(indices);

.as-console-wrapper { max-height: 100% !important; top: 0; }

Javascript通过另一个数组对对象进行排序

2 个答案: