如何按分组与升序重组多层级嵌套对象？

实现思路 #

完成需求需要两个核心步骤：

1. 扁平化嵌套结构：通过递归遍历各层级员工，提取基础属性并生成stacked_code（父级编码与当前编码拼接）
2. 按code升序排序：对扁平化后的数组，按code的数值大小排序（注意code是字符串类型，需转成数值比较）

代码实现 #

// 递归扁平化嵌套员工数组的函数
function flattenEmployees(employees, parentCode = '') {
  return employees.reduce((acc, employee) => {
    // 提取当前员工的基础属性，排除层级数组字段
    const { employee_lvl2, employee_lvl3, ...current } = employee;
    
    // 若有父级编码，生成stacked_code
    if (parentCode) {
      current.stacked_code = `${parentCode}.${employee.code}`;
    }
    
    // 将当前员工加入结果数组
    acc.push(current);
    
    // 递归处理二级员工
    if (employee_lvl2?.length) {
      const parentForLvl2 = parentCode ? `${parentCode}.${employee.code}` : employee.code;
      acc.push(...flattenEmployees(employee_lvl2, parentForLvl2));
    }
    
    // 递归处理三级员工
    if (employee_lvl3?.length) {
      const parentForLvl3 = parentCode ? `${parentCode}.${employee.code}` : employee.code;
      acc.push(...flattenEmployees(employee_lvl3, parentForLvl3));
    }
    
    return acc;
  }, []);
}

// 示例输入数据
const inputEmployees = [
    {
        "id": 5,
        "name": "Jhon",
        "code": "2",
        "employee_lvl2": [
            {
                "id": 23,
                "name": "Rodolf (John's employee 1)",
                "code": "9",
                "employee_lvl3": [
                    {
                        "id": 5,
                        "name": "Marcus (Rodolf's employee 1)",
                        "code": "18"
                    }
                ]
            },
            {
                "id": 17,
                "name": "Samuel (John's employee 2)",
                "code": "16",
                "employee_lvl3": [
                    {
                        "id": 11,
                        "name": "Jacob (Samuel's employee 1)",
                        "code": "21"
                    },
                    {
                        "id": 18,
                        "name": "Agnes (Samuel's employee 2)",
                        "code": "31"
                    }
                ]
            }
        ]
    },
    {
        "id": 4,
        "name": "Jennifer",
        "code": "1",
        "employee_lvl2": [
            {
                "id": 8,
                "name": "James (Jennifer's employee 1)",
                "code": "3",
                "employee_lvl3": [
                    {
                        "id": 12,
                        "name": "Jonathan (James's employee 1)",
                        "code": "8"
                    },
                    {
                        "id": 8,
                        "name": "Agnes (James's employee 2)",
                        "code": "3"
                    }
                ]
            },
            {
                "id": 7,
                "name": "Julie (Jennifer's employee 2)",
                "code": "6",
                "employee_lvl3": [
                    {
                        "id": 1,
                        "name": "Jacob (Julie's employee 1)",
                        "code": "1"
                    }
                ]
            }
        ]
    }
];

// 扁平化数组
const flattened = flattenEmployees(inputEmployees);

// 按code升序排序（处理字符串类型的数字排序）
const sortedResult = flattened.sort((a, b) => parseInt(a.code, 10) - parseInt(b.code, 10));

console.log(JSON.stringify(sortedResult, null, 2));

代码说明 #

1. 递归扁平化：
   • 用reduce遍历数组，每次迭代提取当前员工的非层级属性
   • 根据父级编码生成stacked_code，一级员工无父级，因此不添加该属性
   • 递归处理employee_lvl2和employee_lvl3，传递当前员工编码作为子节点的父级编码
2. 排序逻辑：
   • 由于code是字符串类型，直接比较会出现"10" < "2"的错误，因此先转成整数再做差值比较

输出结果 #

运行代码后会生成符合需求的线性数组，包含正确的stacked_code且按code升序排列。

内容的提问来源于stack exchange，提问作者Jonathan Reis