Javascript 对类别和子类别数组进行排序

假设我们有一组对象，其中每个对象表示一个类别或子类别，如下所示：

var data = [
    {type: "parent-category", order: 1, categoryId: 1},
    {type: "parent-category", order: 2, categoryId: 2},
    {type: "child-category", order: 1, categoryId: 3, parentCategoryId: 1},
    {type: "child-category", order: 2, categoryId: 4, parentCategoryId: 1},
    {type: "child-category", order: 2, categoryId: 5, parentCategoryId: 2},
    {type: "child-category", order: 1, categoryId: 6, parentCategoryId: 2}
];

var data = [
    {type: "parent-category", order: 1, categoryId: 1},
    {type: "child-category", order: 1, categoryId: 3, parentCategoryId: 1},
    {type: "child-category", order: 2, categoryId: 4, parentCategoryId: 1},
    {type: "parent-category", order: 2, categoryId: 2},
    {type: "child-category", order: 1, categoryId: 6, parentCategoryId: 2},
    {type: "child-category", order: 2, categoryId: 5, parentCategoryId: 2}   
];

此数组表示一个具有两个类别的示例，其中每个类别还具有两个子类别

现在，我面临着以某种自定义方式对该数组进行排序的问题。正如您所注意到的，每个对象中的

order

属性与对象在其层次结构中的位置（或顺序）相关。类别和子类别之间的关系由atributte

parentCategoryId

定义

以前面的数据数组为例，我需要的预期排序应该是：

var data = [
    {type: "parent-category", order: 1, categoryId: 1},
    {type: "parent-category", order: 2, categoryId: 2},
    {type: "child-category", order: 1, categoryId: 3, parentCategoryId: 1},
    {type: "child-category", order: 2, categoryId: 4, parentCategoryId: 1},
    {type: "child-category", order: 2, categoryId: 5, parentCategoryId: 2},
    {type: "child-category", order: 1, categoryId: 6, parentCategoryId: 2}
];

var data = [
    {type: "parent-category", order: 1, categoryId: 1},
    {type: "child-category", order: 1, categoryId: 3, parentCategoryId: 1},
    {type: "child-category", order: 2, categoryId: 4, parentCategoryId: 1},
    {type: "parent-category", order: 2, categoryId: 2},
    {type: "child-category", order: 1, categoryId: 6, parentCategoryId: 2},
    {type: "child-category", order: 2, categoryId: 5, parentCategoryId: 2}   
];

我目前解决此问题的方法是创建数字映射，在以下条件下分析属性值：

• 对于类型为父类别的对象，我们指定

  categoryId*1000

  的值
• 对于具有类子类别的对象我们指定

  （parentCategoryId*1000）+顺序的值

此逻辑显示在下一个排序实现中：

let数据=[
{类型：“父类别”，顺序：1，类别ID:1}，
{类型：“父类别”，顺序：2，类别ID:2}，
{类型：“子类别”，顺序：1，类别ID:3，父类别ID:1}，
{类型：“子类别”，顺序：2，类别ID:4，父类别ID:1}，
{类型：“子类别”，顺序：2，类别ID:5，父类别ID:2}，
{类型：“子类别”，顺序：1，类别ID:6，父类别ID:2}
];
让orderedData=data.sort（（a，b）=>
{
var aCat=（a.type=“父类别”）？a.categoryId:a.parentCategoryId；
var aoorder=（a.type=“父类别”）？0:a.order；
var bCat=（b.type=“父类别”）？b.categoryId:b.parentCategoryId；
var bOrder=（b.type=“父类别”）？0:b.order；
返回（aCat*1000+订单）-（bCat*1000+边框）；
});
console.log（orderedData）为方便起见，请使用


如果您不喜欢lodash，可以在
sort

我还没有完全理解你的分类标准，但是，例如

function sort_categories(cat1,cat2) {
  if (cat1["order"] < cat2["order"])
    return -1;
  if (cat1["order"] > cat2["order"])
    return 1;
  return 0;
}

data.sort(sort_categories);

功能排序\u类别（cat1、cat2）{
如果（第1类[“订单”]<第2类[“订单”]）
返回-1；
如果（第1类[“订单”]>第2类[“订单”]）
返回1；
返回0；
}
数据分类（分类）；

只需按订单排序即可

有关返回值的详细信息，请参阅

如果提供了compareFunction，则会删除所有未定义的数组元素
根据比较函数的返回值排序（全部
未定义的元素排序到数组的末尾，不调用
比较函数）。如果a和b是要比较的两个元素，则：


如果比较函数（a，b）小于0，则将a排序到低于b的索引（即a排在第一位）

如果compareFunction（a，b）返回0，则使a和b彼此保持不变，但根据所有不同的值进行排序
元素。注意：ECMAscript标准不能保证这一点
行为，因此并非所有浏览器（例如Mozilla版本）
至少回到2003年）尊重这一点

如果compareFunction（a，b）大于0，则将b排序到低于a的索引（即b排在第一位）

当给定一对特定的元素a和b作为其两个参数时，compareFunction（a，b）必须始终返回相同的值。如果
如果返回不一致的结果，则未定义排序顺序


如果性能不是一个问题，我更愿意采用更循序渐进的方式：


/*原始数据*/
常数数据=[
{类型：“父类别”，顺序：1，类别ID:1}，
{类型：“父类别”，顺序：2，类别ID:2}，
{类型：“子类别”，顺序：1，类别ID:3，父类别ID:1}，
{类型：“子类别”，顺序：2，类别ID:4，父类别ID:1}，
{类型：“子类别”，顺序：2，类别ID:5，父类别ID:2}，
{类型：“子类别”，顺序：1，类别ID:6，父类别ID:2}
];
常量排序=[]；
constbyorder=（a，b）=>a.order-b.order；
//首先找到并分类父母
const parents=data.filter（obj=>obj.type==='parent category'）；
父母。排序（按顺序）；
//按父级顺序推送到结果数组
parents.forEach（obj=>{
分类推送（obj）；
//获取并排序相应的子对象
const children=data.filter（o=>o.parentCategoryId===obj.categoryId）；
儿童。排序（按顺序）；
//将OBJ一起推入结果数组
排序。推送。应用（排序，子项）；
});
控制台日志（已排序）使用数组#过滤器数组#排序和数组#映射的简单性能解决方案


var data=[{type:“父类别”，顺序：1，categoryId:1}，{type:“父类别”，顺序：2，categoryId:2}，{type:“子类别”，顺序：1，categoryId:3，parentCategoryId:1}，{type:“子类别”，顺序：2，categoryId:4，parentCategoryId:1}，{type:“子类别”，顺序：2，categoryId:5，parentCategoryId:2}，{type:“子类别”，顺序：1，类别ID:6，父类别ID:2}]
设res=数据
.filter（（{type}）=>type==“父类别”）
.sort（（a，b）=>a.order-b.order）
.减少（（会计科目，当前）=>{
const children=数据
.filter（（{parentCategoryId}）=>parentCategoryId==curr.categoryId）
.sort（（a，b）=>a.order-b.order）；
acc.push（当前，…儿童）；
返回acc；
}, []);
控制台日志（res）这将起作用。首先对类别ID进行排序，然后通过运行forEach函数进行计算


var数据=[
{类型：“父类别”，顺序：1，类别ID:1}，
{类型：“父类别”，顺序：2，类别ID:2}，
{类型：“子类别”，顺序：1，类别ID:3，父类别ID:1}，
{类型：“子类别”，顺序：2，类别ID:4，父类别ID:1}，
{类型：“子类别”，顺序：2，类别i