Javascript 如何从一个数组中未包含在第二个数组中的对象最佳地创建对象数组

我想要一个数组，该数组包含

刮取

对象中不在

旧

对象中的对象。我实际使用的数组包含近100个对象

下面的代码是有效的，但我想知道是否有更有效的方法来获得相同的结果

var old = [
  {a: 6, b: 3},
  {a: 1, b: 1}, 
  {a: 3, b: 3}
]

var scrape = [
  {a: 1, b: 1}, 
  {a: 5, b:5}
]

var nogood = []
var good =[]

scrape.forEach(es => {
  old.forEach(e => {
    if(e.a == es.a) {
      nogood.push(es)
    }
  })
})
console.log(nogood)

nogood.forEach(main =>   
  good = scrape.filter(e=> e.a!=main.a)  
)
console.log(good)

这就是我的期望和收获：

good = {a:5, b:5}

---

像这样的怎么样

const good = scrape.filter((sEl) => {
  return !old.some(oEl => oEl.a === sEl.a);
})

这避免了嵌套的forEach循环和

。一些

将在找到单个真实条件后立即返回，从而避免在“旧”数组的早期存在元素时进行过度搜索。

可能类似于：

var old=[
{a:6，b:3}，
{a:1，b:1}，
{a:3，b:3}
]
变量刮取=[
{a:1，b:1}，
{a:5，b:5}
]
var result=scrape.filter（s=>old.findIndex（o=>o.a==s.a）=-1）；
控制台日志（结果）就我个人而言，我会用以下方法来解决这个问题：

const old = [
  {a: 6, b: 3},
  {a: 1, b: 1}, 
  {a: 3, b: 3}
];

const scrape = [{a: 1, b: 1}, {a: 5, b:5}];

for (const item of old) {
  for (const i in scrape) {
    if (JSON.stringify(item) === JSON.stringify(scrape[i])) {
      scrape.splice(i, 1); //delete the previously scraped item
    }
  }
} 

console.log(scrape); //{a: 5, b:5}

这种方法的好处是：


你不在乎你比较的对象有什么属性，
你只关心它们是否相同
很快
（比较JSON通常比将对象遍历到
比较每个属性）
拼接刮痕更简洁
数组，而不是添加“good”和“nogood”数组
经过过滤的刮取数组

如果要比较的对象包含方法，则可能会破坏交易，在这种情况下，通过JSON进行比较不是正确的方法

如果数组
旧的
和
刮的
大小分别为
M
和
N
，那么所有传统方法的复杂性都是
O（M*N）
因为您需要将数组
scrape
中的每个条目与数组
old
中存在的条目进行比较，以确定是否匹配

第二种也是更有效的方法是在第一个数组上创建一个哈希表，通常是在较大的数组上（
old
，此处），然后在第二个数组上迭代（
scrape
），其复杂性为
O（M+N）

如果
M
和
N
的大小足够大，差异就会显现出来。例如，如果
M=100
和
N=200
，则前者需要比较
20000
对象，而后者只需要比较
300

请查看此代码：


const old=[
{a:6，b:3}，
{a:1，b:1}，
{a:3，b:3}
]
常数刮取=[
{a:1，b:1}，
{a:5，b:5}
]
//使用内置Javascript映射创建哈希映射
const pair=old.map（x=>[JSON.stringify（x），true]）
常量映射=新映射（对）
//筛选哈希映射中不存在的对象
const good=scrap.filter（x=>！map.has（JSON.stringify（x）））
console.log（好）
请记住，这只与键
a
匹配。谢谢！我在没有哈希图的情况下尝试了你的例子，它似乎也很有效，除非我忽略了什么<代码>变量良好；var old1=old.map（e=>JSON.stringify（e））；good=scrap.filter（e=>！old1.includes（JSON.stringify（e））；控制台日志（良好）
@mac这没问题，但在大型阵列中，这需要时间，因为它的复杂性如上所述为
O（MN）
。使用哈希映射是一种有效的方法。然而，你所做的也是有效的。