如何通过基于特定字段值对对象进行分组来过滤 javascript 对象数组？

Question

下面是我的js对象数组。

const objArray = [
    {
      file: 'file_1',
      start_time: '2021-08-12 14:00:00'
      status: 'pending'
    },
    {
      file: 'file_2',
      start_time: '2021-08-12 14:00:00'
      status: 'completed'
    },
    {
      file: 'file_3',
      start_time: '2021-08-14 15:00:00'
      status: 'pending'
    },
    {
      file: 'file_1',
      start_time: '2021-08-14 03:00:00'
      status: 'pending'
    },
    {
      file: 'file_2',
      start_time: '2021-08-14 03:00:00'
      status: 'pending'
    },
    {
      file: 'file_2',
      start_time: '2021-11-11 11:11:00'
      status: 'pending'
    }
]

从上面的数组中，我需要根据开始时间字段过滤对象。如果开始时间相同，则应将它们分组为子数组。在子数组中也不能有具有相同文件名的对象。例如，在上面的数组中，如果将对象 1&2 与 4&5 进行比较，它们每个都有自己的开始时间值，但它们的文件名相同。因此，我只需要其中一组，即时间戳最低的 1&2。 所以最终的输出数组应该如下，

[
  [
    {
      file: 'file_1',
      start_time: '2021-08-12 14:00:00'
      status: 'pending'
    },
    {
      file: 'file_2',
      start_time: '2021-08-12 14:00:00'
      status: 'completed'
    }
  ],
  [
    {
      file: 'file_3',
      start_time: '2021-08-14 15:00:00'
      status: 'pending'
    }
  ],
  [
    {
      file: 'file_2',
      start_time: '2021-11-11 11:11:00'
      status: 'pending'
    }
  ]
]

我尝试通过遍历初始数组中的每个对象来实现它。但是实现这一目标的最快方法是什么？

Answer 1

任何想在 JavaScript 中执行相当于 SQL GroupBy 的方法的人都不会在这里找到答案。

这个问题是关于一个非常具体的算法，它执行两个步骤：

1. 按日期将记录分组到子数组中
2. 如果两个子数组的记录与完全相同的文件集相关，则认为它们是等效的。
   过滤等效子数组以仅保留日期最早的子数组

---

让我们用一些普通的 JavaScript 来做吧：

function do_some_filtering (records) {

    // create sets containing events grouped by date and index them by date
    let sets = {};
    for (let record of records) {
        // dates are converted to milliseconds since the Epoch for comparison
        let date = Date.parse(record.start_time);
        if (!sets[date]) sets[date] = [record]; else sets[date].push(record);
    }
    
    // filter "unique" sets based on the list of files present in each set
    let unique_date = {};
    for (let date in sets) {
        let signature = sets[date]       // this will concatenate all file names
                       .map(x => x.file) // to create a unique signature for
                       .sort()           // potentially deletable groups
                       .reduce((file,signature) => file+":"+signature)
        // if multiple sets have the same signature, keep the one with the lowest date
        if (!unique_date[signature] || unique_date[signature] > date) {
            unique_date[signature] = date;
        }
    }
    
    // collect "unique" sets
    let result = [];
    for (let signature in unique_date) result.push(sets[unique_date[signature]]);   
    return result;
}

const objArray = [
    {
      file: 'file_1',
      start_time: '2021-08-12 14:00:00',
      status: 'pending'
    },
    {
      file: 'file_2',
      start_time: '2021-08-12 14:00:00',
      status: 'completed'
    },
    {
      file: 'file_3',
      start_time: '2021-08-14 15:00:00',
      status: 'pending'
    },
    {
      file: 'file_1',
      start_time: '2021-08-14 03:00:00',
      status: 'pending'
    },
    {
      file: 'file_2',
      start_time: '2021-08-14 03:00:00',
      status: 'pending'
    },
    {
      file: 'file_2',
      start_time: '2021-11-11 11:11:00',
      status: 'pending'
    }
]

let result = do_some_filtering (objArray);
console.log(JSON.stringify(result, null, "    "));

代码在很大程度上依赖于对象作为关联数组的能力（现代Map 的祖先，有一些限制），随着不变性和函数式编程的出现，这一特性似乎已经被废弃，但是有时仍然被证明非常有用。

说到不变性，记录是不重复的，即在输入中改变一个将反映在输出中，反之亦然。由于记录本身保持不变，这仍然可以实现 JavaScript 在没有专用库的情况下可以提供的那种伪不变性。如果您绝对想要复制，请告诉我，我会更新代码。

我不确定您所说的“最快方式”是什么意思。如果要根据它们包含的文件比较集合，则必须付出比较两个列表的代价，据我所知，如果使用排序，则至少为 O(N log N)，或者O(N²) 如果您进行成对比较。但是除非您打算在数百个文件上使用它，否则包含多个文件的组的数量应该相当少，您几乎不会感觉到差异。
剩下的就是 O(N)，我非常怀疑你可以在不循环所有记录至少一次的情况下实现任何目标。

如果“快速”是指“快速编写”，我猜 15 行原生 JavaScript 应该符合要求？

Answer 2

使用 Saxon-JS 2 (https://www.saxonica.com/saxon-js/index.xml) 提供的 XSLT 3，您可以对 JSON 数据进行分组：

const objArray = [
    {
      file: 'file_1',
      start_time: '2021-08-12 14:00:00',
      status: 'pending'
    },
    {
      file: 'file_2',
      start_time: '2021-08-12 14:00:00',
      status: 'completed'
    },
    {
      file: 'file_3',
      start_time: '2021-08-14 15:00:00',
      status: 'pending'
    },
    {
      file: 'file_1',
      start_time: '2021-08-14 03:00:00',
      status: 'pending'
    },
    {
      file: 'file_2',
      start_time: '2021-08-14 03:00:00',
      status: 'pending'
    },
    {
      file: 'file_2',
      start_time: '2021-11-11 11:11:00',
      status: 'pending'
    }
];

const xslt = `<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
  version="3.0"
  xmlns:xs="http://www.w3.org/2001/XMLSchema"
  exclude-result-prefixes="#all"
  expand-text="yes">

  <xsl:output method="json" indent="yes"/>

  <xsl:template match="." name="xsl:initial-template">
    <xsl:variable name="groups" as="array(*)*">
      <xsl:for-each-group select="?*" group-by="?start_time">
          <xsl:sequence select="array { current-group() }"/>
      </xsl:for-each-group>           
    </xsl:variable>
    <xsl:variable name="filtered-groups" as="array(*)*">
      <xsl:for-each-group select="$groups" composite="yes" group-by="sort(?*?file)">
        <xsl:sort select="?1?start_time"/>
        <xsl:sequence select="."/>
      </xsl:for-each-group>
    </xsl:variable>
    <xsl:sequence select="array { $filtered-groups }"/>
  </xsl:template>
  
</xsl:stylesheet>`;

const resultArray = SaxonJS.XPath.evaluate(`transform(
  map {
    'stylesheet-text' : $xslt,
    'initial-match-selection' : $json,
    'delivery-format' : 'raw'
  }
)?output`, [], { params : { xslt : xslt, json : [objArray] } });

console.log(resultArray);

<script src="https://martin-honnen.github.io/xslt3fiddle/js/SaxonJS2.js"></script>