Javascript 匹配对象数组中的对象并删除

经过两天的努力，我希望有人能帮我解决这个问题

我有两个对象数组，如下所示：

let oldRecords = [
  {name: 'john'},
  {name: 'ringo'}
];

let newRecords = [
  {name: 'paul'},
  {name: 'john'},
  {name: 'stuart'}
];

我试图以一个函数结束，该函数返回包含已添加数据列表的命名变量（存在于

newRecords

中，但不存在于

oldRecords

）和已删除数据列表（存在于

oldRecords

中，但不存在于

newRecords

）

比如说

const analyse = (older, newer) => {
  let added, removed;
    // ... magic
  return {added, removed}
}

const {added, removed} = analyse(oldRecords, newRecords);

我不会在这个函数中发布我尝试过的所有代码，因为我在过去48小时内尝试映射、减少和循环两个数组，创建临时数组，现在我可以用我编写和删除的代码填充一本书。我还使用了underline.js方法，如

reject

/

find

/

findWhere

，这些方法都让我很接近，但没有雪茄

我遇到的主要问题是因为数组包含对象，如果数组包含数字，那么就非常容易了

var oldRecords = [1, 3];
var newRecords = [1, 2, 4]

function analyse (old, newer) { 
  let added = [];
  let removed = [];

  old.reduce((o) => {
    added = added.concat(_.reject(newer, (num) => num === o ));
  });

  newer.reduce((n) => {
    removed = _.reject(old, (num) => num === n );
  });

  return {added, removed}
}

const {added, removed} = analyse(oldRecords, newRecords);

我如何在对象而不是数组的情况下实现上述功能

n、 b.我尝试修改上述内容并使用

JSON.stringify

，但没有真正起作用

编辑：重要的一点我忘了添加，对象结构和它的

键

是动态的，它们来自数据库，因此对

键

的任何单独检查也必须是动态的，即不是硬编码值

您可以使用并检查是否包含在适当的集合中。该函数用于检查处理动态关键点的相等性：

const analyse = (older, newer) => {
  let added = _.reject(newer, n => _.some(older, o =>_.isEqual(n, o)));
  let removed = _.reject(older, o => _.some(newer, n => _.isEqual(n, o)));

  return {added, removed}
}

您可以使用和检查是否包含在适当的集合中。该函数用于检查处理动态关键点的相等性：

const analyse = (older, newer) => {
  let added = _.reject(newer, n => _.some(older, o =>_.isEqual(n, o)));
  let removed = _.reject(older, o => _.some(newer, n => _.isEqual(n, o)));

  return {added, removed}
}

你可以试试这个：

const analyse = (older, newer) => {
   let removed = older.filter(newItem => {
     return newer.filter(oldItem => {
        return _.isEqual(newItem, oldItem);
     }).length === 0
   });

   let added = newer.filter(oldItem => {
     return older.filter(newItem => {
        return _.isEqual(newItem, oldItem);
     }).length === 0
   });

   return {added, removed};
}

你可以试试这个：

const analyse = (older, newer) => {
   let removed = older.filter(newItem => {
     return newer.filter(oldItem => {
        return _.isEqual(newItem, oldItem);
     }).length === 0
   });

   let added = newer.filter(oldItem => {
     return older.filter(newItem => {
        return _.isEqual(newItem, oldItem);
     }).length === 0
   });

   return {added, removed};
}

---

您可以首先创建函数来检查两个对象是否相等，然后使用

filter（）

和

some（）

返回结果

让oldRecords=[
{姓名：'约翰'}，
{name:'ringo'}
];
让新记录=[
{名字：'保罗'}，
{姓名：'约翰'}，
{name:'stuart'}
];
函数相等（o1，o2）{
返回Object.keys（o1）.length==Object.keys（o2）.length&&
Object.key（o1）.every（函数）（key）{
返回o2.hasOwnProperty（键）&&o1[key]==o2[key]
})
}
var result={}
result.removed=oldRecords.filter（e=>！newRecords.some（a=>isEqual（e，a）））
result.added=newRecords.filter（e=>！oldRecords.some（a=>isEqual（e，a）））
console.log（result）

您可以首先创建函数来检查两个对象是否相等，然后使用

filter（）

和

some（）

返回结果

让oldRecords=[
{姓名：'约翰'}，
{name:'ringo'}
];
让新记录=[
{名字：'保罗'}，
{姓名：'约翰'}，
{name:'stuart'}
];
函数相等（o1，o2）{
返回Object.keys（o1）.length==Object.keys（o2）.length&&
Object.key（o1）.every（函数）（key）{
返回o2.hasOwnProperty（键）&&o1[key]==o2[key]
})
}
var result={}
result.removed=oldRecords.filter（e=>！newRecords.some（a=>isEqual（e，a）））
result.added=newRecords.filter（e=>！oldRecords.some（a=>isEqual（e，a）））
console.log（result）

您可以按名称检查对象，还是需要检查完整对象？这一点很好，让我意识到我忘记了一个非常重要的限制。对象键是动态的，因此尽管它们都具有相同的键，但键本身来自数据库，因此可以/将更改。所以不能硬编码。这是我发现这是一个棘手的问题的原因之一。你可以按名称检查对象，还是需要检查完整对象？这一点很好，让我意识到我忘记了一个非常重要的限制。对象键是动态的，因此尽管它们都具有相同的键，但键本身来自数据库，因此可以/将更改。所以不能硬编码。这是我发现这是一个棘手的问题的原因之一，汉克斯，看起来真的很好。关于：对象关键点是动态的，你有什么建议。i、 e.对象可能没有

名称

键。这些都是在数据库中设置的，用户将对其进行更改。将谓词更改为使用

isEqual

谢谢，看起来非常好。关于：对象关键点是动态的，你有什么建议。i、 e.对象可能没有

名称

键。这些都是在数据库中设置的，用户将对其进行更改。将谓词更改为使用

isEqual