JS实现按嵌套深度与子元素长度递归排序多层级对象数组

需求说明 #

需要对包含嵌套children数组的对象数组进行全层级递归排序，排序规则如下：

• 优先按当前节点的最大嵌套深度降序排列（深度越深越靠前）
• 若两个节点的最大深度相同，则按其children数组的长度降序排列（子节点越多越靠前）

同时你提到：尝试过递归遍历深度，但不知道如何把最大深度的元素放到顶层，不确定这种方法是否可行。

实现思路 #

1. 递归计算节点最大深度：每个节点的最大深度 = 1（自身层级） + 子节点中的最大深度（如果有子节点），叶子节点（children为空）的深度为1
2. 编写排序比较函数：按照“深度优先，长度次之”的规则，对同一层级的节点进行降序排序
3. 递归遍历排序所有层级：对每个节点的children数组应用排序，再递归处理每个子节点的children，实现全层级排序

完整代码实现 #

// 计算单个节点的最大嵌套深度
function getMaxDepth(node) {
  if (!node.children || node.children.length === 0) {
    return 1;
  }
  // 递归计算所有子节点的深度，取最大值加1（当前节点层级）
  return 1 + Math.max(...node.children.map(child => getMaxDepth(child)));
}

// 排序比较函数：先比深度，再比children长度，降序排列
function compareNodes(a, b) {
  const depthA = getMaxDepth(a);
  const depthB = getMaxDepth(b);
  // 深度不同：深度大的排前面
  if (depthA !== depthB) {
    return depthB - depthA;
  }
  // 深度相同：children长度大的排前面
  return b.children.length - a.children.length;
}

// 递归对所有层级的children进行排序
function sortNestedNodes(nodes) {
  // 先对当前层级的节点排序
  const sortedNodes = [...nodes].sort(compareNodes);
  // 递归处理每个子节点的children
  sortedNodes.forEach(node => {
    if (node.children && node.children.length > 0) {
      node.children = sortNestedNodes(node.children);
    }
  });
  return sortedNodes;
}

// 测试示例数据
const sampleData = [
  {
    value: '1',
    children: [
      {
        value: '1.1',
        children: [
          { value: '1.1.1', children: [] }
        ]
      },
      {
        value: '1.2',
        children: [
          {
            value: '1.2.1',
            children: [
              { value: '1.2.1.1', children: [] },
              { value: '1.2.1.2', children: [] }
            ]
          }
        ]
      },
      {
        value: '1.3',
        children: [
          {
            value: '1.3.1',
            children: [
              {
                value: '1.3.1.1',
                children: [
                  { value: '1.3.1.1.1', children: [] }
                ]
              }
            ]
          }
        ]
      }
    ]
  }
];

// 执行排序
const sortedResult = sortNestedNodes(sampleData);
console.log(JSON.stringify(sortedResult, null, 2));

关于“最大深度元素提至顶层”的疑问 #

你提到的思路是可行的，而且我们的实现已经完成了这个效果：

• 递归计算深度后，通过排序函数直接将当前层级中深度最大的节点排在最前面，不需要额外的“移动”操作
• 递归处理所有层级后，整个嵌套结构的每一层都会遵循“最深分支在前”的规则，和你给出的示例结果完全一致

这种方法的优势是逻辑清晰，不需要修改原数据的层级结构，只通过排序就实现需求，避免了复杂的节点移动操作。

内容的提问来源于stack exchange，提问作者sync ilya