Javascript 使用v8&；比较两个对象数组的性能方法；筛选/查找

我有2个（嗯，>2个）对象数组，其结构如下：

const mainArr = [
  { article: "somename-1", price: 10, found: [] },
  { article: "somename-2", price: 20, found: [] },...
];
const toCompareArr = [
  { article: "somename-1", articleFormatted: "0somename-1", price: 20 },
  { article: "somename-3", articleFormatted: "0somename-3", price: 20 },...
];

let i = 0;
let j = 0;
const iMax = mainArr.length;
const jMax = toCompareArr.length;
for (; i < iMax; i++) {
  for (; j < jMax; j++) {
    if (
      mainArr[i].article === toCompareArr[j].article ||
      mainArr[i].article === `00-${toCompareArr[j].articleFormatted}`
    ) {
      mainArr[i].found.push(toCompareArr[j]);
    }
  }

  j = 0;
}

// also tried like this (for + for seems to be more speedy):
/*
let found;
for (; i < iMax; i++) {
  found = toCompareArr.filter(
    item =>
      item.article === mainArr[i].article ||
      item.articleFormatted === mainArr[i].article
  );

  if (found) {
    mainArr[i].found.push(found);
  }
}
*/

对于mainArr我尝试在第二个中找到所有发生的情况，以比较阵列（基本上-我需要为不同的供应商创建价格比较器），如下所示：

const mainArr = [
  { article: "somename-1", price: 10, found: [] },
  { article: "somename-2", price: 20, found: [] },...
];
const toCompareArr = [
  { article: "somename-1", articleFormatted: "0somename-1", price: 20 },
  { article: "somename-3", articleFormatted: "0somename-3", price: 20 },...
];

let i = 0;
let j = 0;
const iMax = mainArr.length;
const jMax = toCompareArr.length;
for (; i < iMax; i++) {
  for (; j < jMax; j++) {
    if (
      mainArr[i].article === toCompareArr[j].article ||
      mainArr[i].article === `00-${toCompareArr[j].articleFormatted}`
    ) {
      mainArr[i].found.push(toCompareArr[j]);
    }
  }

  j = 0;
}

// also tried like this (for + for seems to be more speedy):
/*
let found;
for (; i < iMax; i++) {
  found = toCompareArr.filter(
    item =>
      item.article === mainArr[i].article ||
      item.articleFormatted === mainArr[i].article
  );

  if (found) {
    mainArr[i].found.push(found);
  }
}
*/

但当我有大量数据时，速度非常慢（通常每个数据中大约有80k-100k个数组项）

而我坚持。。。也许有一种方法可以提高过滤器的性能&在这里可以找到吗？我正在使用最新的Node&V8功能。现在比较起来大约需要5分钟，如果是50%（比方说2分钟——这要好得多）

也许我应该彻底改变我的逻辑？使用一些算法（想知道-哪一个）

当我有很多数据时，速度非常慢-通常每个数据中都有大约80k-100k个数组项

为此任务使用。一个好的DBMS应该能够在不到一秒钟的时间内，使用一种或类似的技术来进行比较。当然，如果您坚持的话，您可以在node.js中重新实现这一点-使用文章标识符作为a中的键。

您可以使用

const
mainArr=[{文章：“somename-1”，价格：10，发现：[]}，{文章：“somename-2”，价格：20，发现：[]}，
toCompareArr=[{文章：“somename-1”，文章格式：“0somename-1”，价格：20}，{文章：“somename-3”，文章格式：“0somename-3”，价格：20}]，
map=mainArr.reduce（（m，o）=>m.set（o.article，o），新map）；
用于（让项目进入比较区RR）{
让object=map.get（item.article）| map.get（'00-'+item.article格式）；
如果（！object）继续；
object.found.push（项目）；
}
控制台日志（mainArr）
。作为控制台包装{max height:100%！important；top:0；}
请同时添加所需的结果。顺便说一句，
mainArr[i]。未定义找到的
。“80k-100k数组项”-嗯，您是否正在尝试使用node.js实现内存中的数据库？基本方法是创建某种索引，以便您可以按名称快速查找，而不是对另一个大小类似的数组进行100000次穷举搜索。@Bergi不，不是：）数据是从电子表格中解析的。。。有什么建议吗？像使用mongo/sqlite等？来添加一些背景解释，解释为什么这会有帮助：原始方法的问题是两个嵌套for循环的总运行时间是“二次”的：对于长度
n
的数组，您将有
n
外部迭代次数
n
内部迭代次数<当阵列较大时，代码>n^2

会快速增长。

Map

技术避免了这一点：在构建Map（这是一个循环，在本例中隐藏在

mainArr.reduce

中）之后，您只需要迭代

一次来比较
即可。顺便问一下，是否有可能对上述代码进行调优以与类似的代码进行比较？例如：mainArr的条目带有“somePartNR”，而toCompareArr的条目带有“somePartNR和someadditional”。。。在sql中，我可以只使用article%，但是如何在这里使用地图呢？这取决于比较应该发生在哪里。你有一个实际的例子吗？比如：
const mainArr=[{article:“0500”，price:10，found:[]}，{article:“0600”，price:20，found:[]}；const to comparearr=[{文章：“500A”，文章格式：“0500A”，价格：20}，{文章格式：“600A”，文章格式：“0500A”，价格：20}，…]所以应该类似于
let object=map.get（item.article）| map.get（item.article格式化）| map.get.startsWith（item.article））文章末尾的切片-不是解决方案：）