如何在javascript中找到两个不完全相同的数组之间的差异？我使用下划线，但我对香草JS持开放态度

如果我有两个数组

array1 = [{id: 'id1'}, {id:'id2'}, {id:'id3'}, {id:'id3'}]
array2 = [{id: 'id1'}, {id:'id2'}, {id:'id3'}]

预期结果应该是

[{id:'id3'}]

我的方法适用于不同的数组

idsFrom1 = _.pluck(array1, 'id');
idsFrom2 = _.pluck(array2, 'id');
var diff = _.difference(_.union(idsFrom1, idsFrom2), _.intersection(idsFrom1, idsFrom2))

---

我认为您的问题是，您必须使用某种机制来计算已删除的元素，例如

。

：

var first=[{
id:'id1'
}, {
id:'id2'
}, {
id:'id3'
}, {
id:'id3'
}]
第二个变量=[{
id:'id1'
}, {
id:'id2'
}, {
id:'id3'
}]
函数展开（o）{
返回[本]
}
函数换行（k）{
返回u.object（[k]，[String（this）]）
}
函数计数（数组）{
return u.countBy（数组，展开'id'）
}
函数常数（）{
返回字符串（this）
}
功能差异（第一、第二）{
返回0.flant（0.values（0.mapObject（计数（第一个））函数（v，k）{
返回范围（0，v-此[k]）.map（常数，k）
}，计数（秒））.map（换行“id”）
}
console.log（差异（第一、第二））

---

我认为您的问题是您必须使用某种机制来计算已删除的元素，例如

var first=[{
id:'id1'
}, {
id:'id2'
}, {
id:'id3'
}, {
id:'id3'
}]
第二个变量=[{
id:'id1'
}, {
id:'id2'
}, {
id:'id3'
}]
函数展开（o）{
返回[本]
}
函数换行（k）{
返回u.object（[k]，[String（this）]）
}
函数计数（数组）{
return u.countBy（数组，展开'id'）
}
函数常数（）{
返回字符串（this）
}
功能差异（第一、第二）{
返回0.flant（0.values（0.mapObject（计数（第一个））函数（v，k）{
返回范围（0，v-此[k]）.map（常数，k）
}，计数（秒））.map（换行“id”）
}
console.log（差异（第一、第二））

---

此方法逐步遍历其中一个数组，并在数组中移动时从两个匹配的数组中删除元素。这样，两个阵列中没有合作伙伴的任何内容都将保留到最后：

var array1=[{id:'id1'}，{id:'id2'}，{id:'id3'}，{id:'id3'}]
var array2=[{id:'id1'}，{id:'id2'}，{id:'id3'}]
idsFrom1=u2;.pull（数组1，'id'）；
idsFrom2=u2;.pull（array2，'id'）；
对于（变量i=0；i-1）{
idsFrom1.拼接（i，1）；
idsFrom2.拼接（索引1）；
}
否则i++；
}
diff=[].concat（idsFrom1，idsFrom2）；
objarr=[]；
对于（var i=0；i，此方法逐步遍历其中一个数组，并在数组中移动时从两个数组中删除匹配的元素。这样，两个数组中没有伙伴的任何元素都将保留在最后：


var array1=[{id:'id1'}，{id:'id2'}，{id:'id3'}，{id:'id3'}]
var array2=[{id:'id1'}，{id:'id2'}，{id:'id3'}]
idsFrom1=u2;.pull（数组1，'id'）；
idsFrom2=u2;.pull（array2，'id'）；
对于（变量i=0；i-1）{
idsFrom1.拼接（i，1）；
idsFrom2.拼接（索引1）；
}
否则i++；
}
diff=[].concat（idsFrom1，idsFrom2）；
objarr=[]；
对于（var i=0；i请尝试此操作。如果不想修改原始数组，则可以创建副本并使用它们进行修改


var数组1=[{
id:'id1'
}, {
id:'id2'
}, {
id:'id3'
}, {
id:'id3'
}],
阵列2=[{
id:'id1'
}, {
id:'id2'
}, {
id:'id3'
}];
_.每个（阵列1，功能（obj1，i）{
_.每个（阵列2，功能（obj2，j）{
//确保对象未被上一次比较清除
var isEqual=array1[i]&&array2[j]&&&&u2.isEqual（obj1，obj2）；
如果（等质量）{
array1[i]=array2[j]=null；
}
});
});
console.log（[].concat（u.compact（array1），u.compact（array2））；
试试这个。如果不想修改原始阵列，可以创建副本并使用它们进行修改


var数组1=[{
id:'id1'
}, {
id:'id2'
}, {
id:'id3'
}, {
id:'id3'
}],
阵列2=[{
id:'id1'
}, {
id:'id2'
}, {
id:'id3'
}];
_.每个（阵列1，功能（obj1，i）{
_.每个（阵列2，功能（obj2，j）{
//确保对象未被上一次比较清除
var isEqual=array1[i]&&array2[j]&&&&u2.isEqual（obj1，obj2）；
如果（等质量）{
array1[i]=array2[j]=null；
}
});
});
console.log（[].concat（u.compact（array1），u.compact（array2））；
此函数不使用splice（），而是通过将其设置为null来“标记”应删除的每个数组成员，然后使用compact（）一次将它们全部删除。随着idsFrom2使用splice变小，indexOf（）的速度实际上会提高，因此更快的方法取决于匹配的数量和数组的大小


array1=[{id:'id1'}，{id:'id2'}，{id:'id3'}，{id:'id3'}]
array2=[{id:'id1'}，{id:'id2'}，{id:'id3'}]
idsFrom1=u2;.pull（数组1，'id'）；
idsFrom2=u2;.pull（array2，'id'）；
对于（变量i=0；i-1）{
idsFrom1[i]=null；
idsFrom2[index]=null；
}
}
diff=[].concat（0.compact（idsFrom1），0.compact（idsFrom2））；
objarr=[]；
对于（var i=0；i此函数不使用splice（），而是通过将其设置为null来“标记”应删除的每个数组成员，然后使用compact（）一次将它们全部删除。随着idsFrom2使用splice变小，indexOf（）的速度实际上会提高，因此更快的方法取决于匹配的数量和数组的大小


array1=[{id:'id1'}，{id:'id2'}，{id:'id3'}，{id:'id3'}]
array2=[{id:'id1'}，{id:'id2'}，{id:'id3'}]
idsFrom1=u2;.pull（数组1，'id'）；
idsFrom2=u2;.pull（array2，'id'）；
对于（变量i=0；i-1）{
idsFrom1[i]=null；
idsFrom2[index]=null；
}
}
diff=[].concat（0.compact（idsFrom1），0.compact（idsFrom2））；
objarr=[]；
对于（var i=0；iOk），这是我所有测试中速度最快的一个。使用idsFrom2数组上的splice（）使其在通过idsFrom1时收缩，并在idsFrom1数组匹配项上设置null，然后使用compact（）


var array1=[{id:'id1'}，{id:'id2'}，{id:'id3'}，{id:'id3'}]；
var array2=[{id:'id1'}，{id:'id2'}，{id:'id3'}]；
idsFrom1=u0.pluc