JavaScript按activeSince属性排序嵌套对象数组的问题

问题描述 #

需要依据activeSince属性对嵌套结构的对象数组进行整体排序：既要对每个顶层对象的chats子数组排序，也要让顶层对象根据其chats子数组的activeSince特征值排序。但当前实现仅能正确排序子数组，顶层对象排序逻辑错误——原代码先排序顶层数组（依赖未排序的子数组第一个元素），再排序子数组，导致顶层排序依据失效。

原代码与核心问题 #

原排序函数 #

function sortChatsByActiveSince(filteredData) {
  filteredData.sort((a, b) => {
      if (a.chats.length === 0 && b.chats.length === 0) return 0;
      if (a.chats.length === 0) return  1;
      if (b.chats.length === 0) return -1;

      if (this.sortOrder === "asc") {
        return a.chats[0].activeSince - b.chats[0].activeSince;
      } else {
        return b.chats[0].activeSince - a.chats[0].activeSince;
      }
    });
    for (let data of filteredData) {
      data.chats.sort((a, b) => {
        if (this.sortOrder === "asc") {
          return a.activeSince - b.activeSince;
        } else {
          return b.activeSince - a.activeSince;
        }
      });
    }
    console.log(JSON.stringify(filteredData, null, 2))
}

核心问题 #

1. 排序顺序错误：先排序顶层数组，再排序子数组，导致顶层排序时使用的chats[0]是未排序的旧值，子数组排序后chats[0]改变，顶层排序结果不符合预期。
2. 排序依据不严谨：默认用子数组第一个元素作为顶层排序依据，但未明确该元素是否是子数组中符合排序逻辑的极值（最大/最小值）。

可行实现方式 #

方案1：先排序子数组，再基于子数组极值排序顶层 #

先对每个顶层对象的chats子数组完成排序，此时子数组的第一个元素就是该数组的极值（降序为最大值，升序为最小值），再用这个极值作为顶层对象的排序依据：

function sortChatsByActiveSince(filteredData, sortOrder = "desc") {
  // 1. 先排序每个顶层对象的chats子数组
  filteredData.forEach(data => {
    data.chats.sort((a, b) => {
      return sortOrder === "asc" 
        ? a.activeSince - b.activeSince 
        : b.activeSince - a.activeSince;
    });
  });

  // 2. 基于子数组的极值（排序后的第一个元素）排序顶层数组
  filteredData.sort((a, b) => {
    if (a.chats.length === 0 && b.chats.length === 0) return 0;
    if (a.chats.length === 0) return 1; // 空chats排最后
    if (b.chats.length === 0) return -1;

    const aActive = a.chats[0].activeSince;
    const bActive = b.chats[0].activeSince;

    return sortOrder === "asc" 
      ? aActive - bActive 
      : bActive - aActive;
  });

  console.log(JSON.stringify(filteredData, null, 2));
}

方案2：直接计算子数组极值，不依赖子数组排序顺序 #

如果不需要依赖子数组的排序结果来获取极值，可以直接计算每个chats数组的最大/最小activeSince值，以此作为顶层排序的依据：

// 辅助函数：获取chats数组的极值activeSince
function getChatExtremeActiveSince(chats, sortOrder) {
  if (chats.length === 0) return null;
  const activeValues = chats.map(chat => chat.activeSince);
  return sortOrder === "asc" 
    ? Math.min(...activeValues)
    : Math.max(...activeValues);
}

function sortChatsByActiveSince(filteredData, sortOrder = "desc") {
  // 1. 排序子数组（按需保留，若不需要子数组排序可删除）
  filteredData.forEach(data => {
    data.chats.sort((a, b) => {
      return sortOrder === "asc" 
        ? a.activeSince - b.activeSince 
        : b.activeSince - a.activeSince;
    });
  });

  // 2. 基于子数组极值排序顶层数组
  filteredData.sort((a, b) => {
    const aExtreme = getChatExtremeActiveSince(a.chats, sortOrder);
    const bExtreme = getChatExtremeActiveSince(b.chats, sortOrder);

    if (aExtreme === null && bExtreme === null) return 0;
    if (aExtreme === null) return 1;
    if (bExtreme === null) return -1;

    return sortOrder === "asc" 
      ? aExtreme - bExtreme 
      : bExtreme - aExtreme;
  });

  console.log(JSON.stringify(filteredData, null, 2));
}

验证效果 #

调用修正后的函数，传入示例数据，会得到符合预期的整体排序结果：顶层对象按其chats子数组的极值activeSince排序，同时每个子数组内部也完成排序。

内容的提问来源于stack exchange，提问作者Muhammad Junaid