如何在Javascript中获取两个数组之间的差异？
有没有办法在JavaScript中返回两个数组之间的差异？
例如：
var a1 = ['a', 'b'];
var a2 = ['a', 'b', 'c', 'd'];
// need ["c", "d"]
任何建议都非常感谢。
76 个答案:
答案 0 :(得分：843)
Array.prototype.diff = function(a) {
return this.filter(function(i) {return a.indexOf(i) < 0;});
};
////////////////////
// Examples
////////////////////
[1,2,3,4,5,6].diff( [3,4,5] );
// => [1, 2, 6]
["test1", "test2","test3","test4","test5","test6"].diff(["test1","test2","test3","test4"]);
// => ["test5", "test6"]
Array.prototype.diff = function(a) {
return this.filter(function(i) {return a.indexOf(i) < 0;});
};
////////////////////
// Examples
////////////////////
var dif1 = [1,2,3,4,5,6].diff( [3,4,5] );
console.log(dif1); // => [1, 2, 6]
var dif2 = ["test1", "test2","test3","test4","test5","test6"].diff(["test1","test2","test3","test4"]);
console.log(dif2); // => ["test5", "test6"]
注意 indexOf和过滤器在ie9之前不可用。
答案 1 :(得分：749)
使用ES7有更好的方法：
<强>交叉口
let intersection = arr1.filter(x => arr2.includes(x));
对于[1,2,3] [2,3]，它会产生[2,3]。另一方面，[1,2,3] [2,3,5]将返回相同的内容。
<强>差分
let difference = arr1.filter(x => !arr2.includes(x));
对于[1,2,3] [2,3]，它会产生[1]。另一方面，[1,2,3] [2,3,5]将返回相同的内容。
对于对称差异，您可以执行以下操作：
let difference = arr1
.filter(x => !arr2.includes(x))
.concat(arr2.filter(x => !arr1.includes(x)));
这样，你将获得一个包含arr1的所有元素的数组，这些元素不在arr2中，反之亦然
正如@Joshaven Potter在答案中指出的那样，你可以将它添加到Array.prototype中，这样就可以这样使用：
Array.prototype.diff = arr1.filter(x => arr2.includes(x));
[1, 2, 3].diff([2, 3])
答案 2 :(得分：300)
这是迄今为止使用jQuery获取您正在寻找的结果的最简单方法：
var diff = $(old_array).not(new_array).get();
diff现在包含old_array中不在new_array
答案 3 :(得分：174)
我假设您正在比较普通数组。如果没有，您需要将 for 循环更改为 for .. in 循环。
function arr_diff (a1, a2) {
var a = [], diff = [];
for (var i = 0; i < a1.length; i++) {
a[a1[i]] = true;
}
for (var i = 0; i < a2.length; i++) {
if (a[a2[i]]) {
delete a[a2[i]];
} else {
a[a2[i]] = true;
}
}
for (var k in a) {
diff.push(k);
}
return diff;
}
console.log(arr_diff(['a', 'b'], ['a', 'b', 'c', 'd']));
console.log(arr_diff("abcd", "abcde"));
console.log(arr_diff("zxc", "zxc"));
如果您不关心向后兼容性，更好的解决方案是使用过滤器。但是，这个解决方案仍有效。
答案 4 :(得分：148)
The difference method in Underscore（或其直接替代，Lo-Dash）也可以这样做：
(R)eturns the values from array that are not present in the other arrays
_.difference([1, 2, 3, 4, 5], [5, 2, 10]);
=> [1, 3, 4]
与任何Underscore功能一样，您也可以使用更面向对象的风格：
_([1, 2, 3, 4, 5]).difference([5, 2, 10]);
答案 5 :(得分：64)
普通JavaScript
“差异”有两种可能的解释。我会让你选择你想要的那个。说你有：
var a1 = ['a', 'b' ];
var a2 = [ 'b', 'c'];
-
如果您想获得
['a']，请使用此功能：function difference(a1, a2) { var result = []; for (var i = 0; i < a1.length; i++) { if (a2.indexOf(a1[i]) === -1) { result.push(a1[i]); } } return result; } -
如果您想获得
['a', 'c']（a1或a2中包含的所有元素，而不是两者都包含 - 所谓的对称差异），使用此函数：function symmetricDifference(a1, a2) { var result = []; for (var i = 0; i < a1.length; i++) { if (a2.indexOf(a1[i]) === -1) { result.push(a1[i]); } } for (i = 0; i < a2.length; i++) { if (a1.indexOf(a2[i]) === -1) { result.push(a2[i]); } } return result; }
Lodash / Underscore
如果您使用的是lodash，则可以使用_.difference(a1, a2)（上述案例1）或_.xor(a1, a2)（案例2）。
如果您使用的是Underscore.js，则可以使用案例1的_.difference(a1, a2)功能。
ES6设置，适用于非常大的数组
上述代码适用于所有浏览器。但是，对于超过10,000个项目的大型数组，它变得非常慢，因为它具有O（n²）复杂度。在许多现代浏览器中，我们可以利用ES6 Set对象来加快速度。当Lodash可用时，它会自动使用Set。如果您不使用lodash，请使用受Axel Rauschmayer's blog post启发的以下实现：
function difference(a1, a2) {
var a2Set = new Set(a2);
return a1.filter(function(x) { return !a2Set.has(x); });
}
function symmetricDifference(a1, a2) {
return difference(a1, a2).concat(difference(a2, a1));
}
备注
如果您关心-0, +0, NaN或稀疏数组，所有示例的行为可能会令人惊讶或不明显。 （对于大多数用途，这没关系。）
答案 6 :(得分：56)
ES6中的一种更清洁的方法是以下解决方案。
select MO.delivery_id,
DS.name,
MO.created_at
from MAINDB_ORDER MO
join maindb_store DS on DS.id = MO.store_id
where exists (
select ISNULL (MO.delivery_id
from MAINDB_DELIVERY_EVENT dwe
where dwe.id is null)
and MO.created_at between '2019-01-01' and '2019-12-31'
limit 1
差异
var a1 = ['a', 'b'];
var a2 = ['a', 'b', 'c', 'd'];
路口
a2.filter(d => !a1.includes(d)) // gives ["c", "d"]
析取联合（对称差）
a2.filter(d => a1.includes(d)) // gives ["a", "b"]
答案 7 :(得分：35)
在这种情况下，您可以使用Set。它针对这种操作进行了优化（联合，交集，差异）。
一旦不允许重复，请确保它适用于您的情况。
var a = new JS.Set([1,2,3,4,5,6,7,8,9]);
var b = new JS.Set([2,4,6,8]);
a.difference(b)
// -> Set{1,3,5,7,9}
答案 8 :(得分：30)
要获得对称差异，您需要以两种方式（或在有多个阵列的情况下以所有方式）比较阵列
ES7（ECMAScript 2016）
// diff between just two arrays:
function arrayDiff(a, b) {
return [
...a.filter(x => !b.includes(x)),
...b.filter(x => !a.includes(x))
];
}
// diff between multiple arrays:
function arrayDiff(...arrays) {
return [].concat(...arrays.map( (arr, i) => {
const others = arrays.slice(0);
others.splice(i, 1);
const unique = [...new Set([].concat(...others))];
return arr.filter(x => !unique.includes(x));
}));
}
ES6（ECMAScript 2015）
// diff between just two arrays:
function arrayDiff(a, b) {
return [
...a.filter(x => b.indexOf(x) === -1),
...b.filter(x => a.indexOf(x) === -1)
];
}
// diff between multiple arrays:
function arrayDiff(...arrays) {
return [].concat(...arrays.map( (arr, i) => {
const others = arrays.slice(0);
others.splice(i, 1);
const unique = [...new Set([].concat(...others))];
return arr.filter(x => unique.indexOf(x) === -1);
}));
}
ES5（ECMAScript 5.1）
// diff between just two arrays:
function arrayDiff(a, b) {
var arrays = Array.prototype.slice.call(arguments);
var diff = [];
arrays.forEach(function(arr, i) {
var other = i === 1 ? a : b;
arr.forEach(function(x) {
if (other.indexOf(x) === -1) {
diff.push(x);
}
});
})
return diff;
}
// diff between multiple arrays:
function arrayDiff() {
var arrays = Array.prototype.slice.call(arguments);
var diff = [];
arrays.forEach(function(arr, i) {
var others = arrays.slice(0);
others.splice(i, 1);
var otherValues = Array.prototype.concat.apply([], others);
var unique = otherValues.filter(function (x, j) {
return otherValues.indexOf(x) === j;
});
diff = diff.concat(arr.filter(x => unique.indexOf(x) === -1));
});
return diff;
}
示例：
// diff between two arrays:
const a = ['a', 'd', 'e'];
const b = ['a', 'b', 'c', 'd'];
arrayDiff(a, b); // (3) ["e", "b", "c"]
// diff between multiple arrays
const a = ['b', 'c', 'd', 'e', 'g'];
const b = ['a', 'b'];
const c = ['a', 'e', 'f'];
arrayDiff(a, b, c); // (4) ["c", "d", "g", "f"]
对象数组之间的差异
function arrayDiffByKey(key, ...arrays) {
return [].concat(...arrays.map( (arr, i) => {
const others = arrays.slice(0);
others.splice(i, 1);
const unique = [...new Set([].concat(...others))];
return arr.filter( x =>
!unique.some(y => x[key] === y[key])
);
}));
}
示例：
const a = [{k:1}, {k:2}, {k:3}];
const b = [{k:1}, {k:4}, {k:5}, {k:6}];
const c = [{k:3}, {k:5}, {k:7}];
arrayDiffByKey('k', a, b, c); // (4) [{k:2}, {k:4}, {k:6}, {k:7}]
答案 9 :(得分：28)
function diff(a1, a2) {
return a1.concat(a2).filter(function(val, index, arr){
return arr.indexOf(val) === arr.lastIndexOf(val);
});
}
合并两个数组，唯一值只出现一次，因此indexOf（）将与lastIndexOf（）相同。
答案 10 :(得分：17)
从另一个数组中减去一个数组，只需使用下面的代码段：
var a1 = ['1','2','3','4','6'];
var a2 = ['3','4','5'];
var items = new Array();
items = jQuery.grep(a1,function (item) {
return jQuery.inArray(item, a2) < 0;
});
它将返回[＆＃39; 1，＆＃39; 2＆＃39;＆＃39; 6＆＃39;]，它们是第一个不存在于第二个数组中的项目。
因此，根据您的问题示例，以下代码是确切的解决方案：
var array1 = ["test1", "test2","test3", "test4"];
var array2 = ["test1", "test2","test3","test4", "test5", "test6"];
var _array = new Array();
_array = jQuery.grep(array2, function (item) {
return jQuery.inArray(item, array1) < 0;
});
答案 11 :(得分：12)
使用indexOf()的解决方案适用于小型数组，但随着它们的长度增长，算法的性能接近O(n^2)。这是一个解决方案，通过使用对象作为关联数组将数组条目存储为键，可以更好地处理非常大的数组;它还自动消除重复条目，但仅适用于字符串值（或可以安全存储为字符串的值）：
function arrayDiff(a1, a2) {
var o1={}, o2={}, diff=[], i, len, k;
for (i=0, len=a1.length; i<len; i++) { o1[a1[i]] = true; }
for (i=0, len=a2.length; i<len; i++) { o2[a2[i]] = true; }
for (k in o1) { if (!(k in o2)) { diff.push(k); } }
for (k in o2) { if (!(k in o1)) { diff.push(k); } }
return diff;
}
var a1 = ['a', 'b'];
var a2 = ['a', 'b', 'c', 'd'];
arrayDiff(a1, a2); // => ['c', 'd']
arrayDiff(a2, a1); // => ['c', 'd']
答案 12 :(得分：11)
ES2015的功能方法
计算两个数组之间的difference是Set个操作之一。该术语已指示应使用本机Set类型，以便提高查找速度。无论如何，当你计算两组之间的差异时，有三种排列：
[+left difference] [-intersection] [-right difference]
[-left difference] [-intersection] [+right difference]
[+left difference] [-intersection] [+right difference]
这是一个反映这些排列的功能性解决方案。
左difference：
＆＃13;
＆＃13;
＆＃13;
＆＃13;
// small, reusable auxiliary functions
const apply = f => x => f(x);
const flip = f => y => x => f(x) (y);
const createSet = xs => new Set(xs);
const filter = f => xs => xs.filter(apply(f));
// left difference
const differencel = xs => ys => {
const zs = createSet(ys);
return filter(x => zs.has(x)
? false
: true
) (xs);
};
// mock data
const xs = [1,2,2,3,4,5];
const ys = [0,1,2,3,3,3,6,7,8,9];
// run the computation
console.log( differencel(xs) (ys) );
右difference：
differencer是微不足道的。只有differencel翻转参数。为方便起见，您可以编写一个函数：const differencer = flip(differencel)。这就是全部！
对称difference：
现在我们有左边和右边的一个，实现对称difference也很简单：
＆＃13;
＆＃13;
＆＃13;
＆＃13;
// small, reusable auxiliary functions
const apply = f => x => f(x);
const flip = f => y => x => f(x) (y);
const concat = y => xs => xs.concat(y);
const createSet = xs => new Set(xs);
const filter = f => xs => xs.filter(apply(f));
// left difference
const differencel = xs => ys => {
const zs = createSet(ys);
return filter(x => zs.has(x)
? false
: true
) (xs);
};
// symmetric difference
const difference = ys => xs =>
concat(differencel(xs) (ys)) (flip(differencel) (xs) (ys));
// mock data
const xs = [1,2,2,3,4,5];
const ys = [0,1,2,3,3,3,6,7,8,9];
// run the computation
console.log( difference(xs) (ys) );
我想这个例子是获得函数式编程意味着什么的一个很好的起点：
使用可以多种方式插入的构建块进行编程。
答案 13 :(得分：11)
随着ES6与套装和splat操作员的到来（在仅在Firefox中工作时，请检查compatibility table），您可以编写以下一个班轮：
var a = ['a', 'b', 'c', 'd'];
var b = ['a', 'b'];
var b1 = new Set(b);
var difference = [...new Set([...a].filter(x => !b1.has(x)))];
将导致[ "c", "d" ]。
答案 14 :(得分：10)
Joshaven Potter的上述答案很棒。但它返回数组B中不在数组C中的元素，但不是相反的方式。例如，如果var a=[1,2,3,4,5,6].diff( [3,4,5,7]);则会输出：==＆gt; [1,2,6]，但不 [1,2,6,7]，这是两者之间的实际差异。您仍然可以使用上面的Potter代码，但只需向后重做一次比较：
Array.prototype.diff = function(a) {
return this.filter(function(i) {return !(a.indexOf(i) > -1);});
};
////////////////////
// Examples
////////////////////
var a=[1,2,3,4,5,6].diff( [3,4,5,7]);
var b=[3,4,5,7].diff([1,2,3,4,5,6]);
var c=a.concat(b);
console.log(c);
这应输出：[ 1, 2, 6, 7 ]
答案 15 :(得分：8)
解决问题的另一种方法
void MainPage::OnNavigatedTo(NavigationEventArgs^ e)
{
auto my_data_file = co_await Windows::ApplicationModel::Package::Current->InstalledLocation->GetFileAsync("samples.txt");
}
答案 16 :(得分：7)
Array.prototype.difference = function(e) {
return this.filter(function(i) {return e.indexOf(i) < 0;});
};
eg:-
[1,2,3,4,5,6,7].difference( [3,4,5] );
=> [1, 2, 6 , 7]
答案 17 :(得分：6)
使用JavaScript的过滤功能的非常简单的解决方案：
getData()
答案 18 :(得分：6)
这个怎么样：
Array.prototype.contains = function(needle){
for (var i=0; i<this.length; i++)
if (this[i] == needle) return true;
return false;
}
Array.prototype.diff = function(compare) {
return this.filter(function(elem) {return !compare.contains(elem);})
}
var a = new Array(1,4,7, 9);
var b = new Array(4, 8, 7);
alert(a.diff(b));
所以这样你可以做array1.diff(array2)来获得它们的差异（算法的时间复杂度很大 - 我相信O（array1.length x array2.length））
答案 19 :(得分：4)
使用http://phrogz.net/JS/ArraySetMath.js，您可以：
var array1 = ["test1", "test2","test3", "test4"];
var array2 = ["test1", "test2","test3","test4", "test5", "test6"];
var array3 = array2.subtract( array1 );
// ["test5", "test6"]
var array4 = array1.exclusion( array2 );
// ["test5", "test6"]
答案 20 :(得分：3)
- 纯JavaScript解决方案（无库）
- 与旧版浏览器兼容（不使用
filter） - 为O（n ^ 2）
- 可选
fn回调参数，可让您指定如何比较数组项
function diff(a, b, fn){
var max = Math.max(a.length, b.length);
d = [];
fn = typeof fn === 'function' ? fn : false
for(var i=0; i < max; i++){
var ac = i < a.length ? a[i] : undefined
bc = i < b.length ? b[i] : undefined;
for(var k=0; k < max; k++){
ac = ac === undefined || (k < b.length && (fn ? fn(ac, b[k]) : ac == b[k])) ? undefined : ac;
bc = bc === undefined || (k < a.length && (fn ? fn(bc, a[k]) : bc == a[k])) ? undefined : bc;
if(ac == undefined && bc == undefined) break;
}
ac !== undefined && d.push(ac);
bc !== undefined && d.push(bc);
}
return d;
}
alert(
"Test 1: " +
diff(
[1, 2, 3, 4],
[1, 4, 5, 6, 7]
).join(', ') +
"\nTest 2: " +
diff(
[{id:'a',toString:function(){return this.id}},{id:'b',toString:function(){return this.id}},{id:'c',toString:function(){return this.id}},{id:'d',toString:function(){return this.id}}],
[{id:'a',toString:function(){return this.id}},{id:'e',toString:function(){return this.id}},{id:'f',toString:function(){return this.id}},{id:'d',toString:function(){return this.id}}],
function(a, b){ return a.id == b.id; }
).join(', ')
);
答案 21 :(得分：3)
这是有效的：基本上合并两个数组，查找重复项并将不重复的内容推送到新数组中，这是不同的。
＆＃13;
＆＃13;
＆＃13;
＆＃13;
function diff(arr1, arr2) {
var newArr = [];
var arr = arr1.concat(arr2);
for (var i in arr){
var f = arr[i];
var t = 0;
for (j=0; j<arr.length; j++){
if(arr[j] === f){
t++;
}
}
if (t === 1){
newArr.push(f);
}
}
return newArr;
}
答案 22 :(得分：3)
使用额外的内存来执行此操作。这样一来，您可以以较少的时间复杂度来解决它，而不是o（n * n），而是O（n）。
var promise = axios
.post('executeTask', {
id,
status,
name
});
// show message here
promise.then(response => {
})
.catch(error => {
});
答案 23 :(得分：3)
要找出没有重复的 2 个数组的差异：
function difference(arr1, arr2){
let setA = new Set(arr1);
let differenceSet = new Set(arr2.filter(ele => !setA.has(ele)));
return [...differenceSet ];
}
1.difference([2,2,3,4],[2,3,3,4]) 将返回 []
2.difference([1,2,3],[4,5,6]) 将返回 [4,5,6]
3.difference([1,2,3,4],[1,2]) 将返回 []
4.difference([1,2],[1,2,3,4]) 将返回 [3,4]
注意：上述解决方案要求您始终将较大的数组作为第二个参数发送。要找到绝对差异，您需要先找到两者中较大的数组，然后再处理它们。
要找出没有重复的 2 个数组的绝对差：
function absDifference(arr1, arr2){
const {larger, smaller} = arr1.length > arr2.length ?
{larger: arr1, smaller: arr2} : {larger: arr2, smaller: arr1}
let setA = new Set(smaller);
let absDifferenceSet = new Set(larger.filter(ele => !setA.has(ele)));
return [...absDifferenceSet ];
}
1.absDifference([2,2,3,4],[2,3,3,4]) 将返回 []
2.absDifference([1,2,3],[4,5,6]) 将返回 [4,5,6]
3.absDifference([1,2,3,4],[1,2]) 将返回 [3,4]
4.absDifference([1,2],[1,2,3,4]) 将返回 [3,4]
注意两个解决方案中的示例 3
答案 24 :(得分：3)
function diffArray(arr1, arr2) {
var newArr = arr1.concat(arr2);
return newArr.filter(function(i){
return newArr.indexOf(i) == newArr.lastIndexOf(i);
});
}
这对我有用
答案 25 :(得分：2)
只是想......为了挑战;-)这会工作......（对于字符串，数字等的基本数组）没有嵌套数组
function diffArrays(arr1, arr2, returnUnion){
var ret = [];
var test = {};
var bigArray, smallArray, key;
if(arr1.length >= arr2.length){
bigArray = arr1;
smallArray = arr2;
} else {
bigArray = arr2;
smallArray = arr1;
}
for(var i=0;i<bigArray.length;i++){
key = bigArray[i];
test[key] = true;
}
if(!returnUnion){
//diffing
for(var i=0;i<smallArray.length;i++){
key = smallArray[i];
if(!test[key]){
test[key] = null;
}
}
} else {
//union
for(var i=0;i<smallArray.length;i++){
key = smallArray[i];
if(!test[key]){
test[key] = true;
}
}
}
for(var i in test){
ret.push(i);
}
return ret;
}
array1 = "test1", "test2","test3", "test4", "test7"
array2 = "test1", "test2","test3","test4", "test5", "test6"
diffArray = diffArrays(array1, array2);
//returns ["test5","test6","test7"]
diffArray = diffArrays(array1, array2, true);
//returns ["test1", "test2","test3","test4", "test5", "test6","test7"]
请注意，排序可能不会如上所述...但如果需要，请调用数组上的.sort（）进行排序。
答案 26 :(得分：2)
// es6方法
function diff(a, b) {
var u = a.slice(); //dup the array
b.map(e => {
if (u.indexOf(e) > -1) delete u[u.indexOf(e)]
else u.push(e) //add non existing item to temp array
})
return u.filter((x) => {return (x != null)}) //flatten result
}
答案 27 :(得分：2)
function diff(arr1, arr2) {
var filteredArr1 = arr1.filter(function(ele) {
return arr2.indexOf(ele) == -1;
});
var filteredArr2 = arr2.filter(function(ele) {
return arr1.indexOf(ele) == -1;
});
return filteredArr1.concat(filteredArr2);
}
diff([1, "calf", 3, "piglet"], [1, "calf", 3, 4]); // Log ["piglet",4]
答案 28 :(得分：2)
如果数组不是简单类型，则可以调整上述答案之一：
Array.prototype.diff = function(a) {
return this.filter(function(i) {return a.map(function(e) { return JSON.stringify(e); }).indexOf(JSON.stringify(i)) < 0;});
};
此方法适用于复杂对象的数组。
答案 29 :(得分：2)
这是受到Thinker接受的答案的启发，但Thinker的回答似乎假设数组是集合。如果数组是[ "1", "2" ]和[ "1", "1", "2", "2" ]
这些数组之间的差异是[ "1", "2" ]。以下解决方案是O（n * n），因此不太理想，但如果你有大数组，它也有比Thinker解决方案更好的内存优势。
如果您首先处理套装，那么Thinker的解决方案肯定会更好。如果您有更新版本的Javascript可以访问过滤器，那么您也应该使用它们。这仅适用于那些没有处理集合并使用较旧版本的JavaScript（无论出于何种原因）的人......
if (!Array.prototype.diff) {
Array.prototype.diff = function (array) {
// if the other array is a falsy value, return a copy of this array
if ((!array) || (!Array.prototype.isPrototypeOf(array))) {
return this.slice(0);
}
var diff = [];
var original = this.slice(0);
for(var i=0; i < array.length; ++i) {
var index = original.indexOf(array[i]);
if (index > -1) {
original.splice(index, 1);
} else {
diff.push(array[i]);
}
}
for (var i=0; i < original.length; ++i) {
diff.push(original[i]);
}
return diff;
}
}
答案 30 :(得分：2)
require(sde)
require(yuima)
require(stats4)
set.seed(123456789)
X <- read.csv(header = FALSE, "data.csv", sep = "," )
X$date <- as.Date(X$date, format = "%m/%d/%Y")
#X$date <- difftime(X$date, X$date[1], units = 'day')
X <- zoo(X)
mod1 <- setModel(drift="(2-theta2*x)",diffusion="(1+x^2)^theta1")
yuima1 <- setYuima(model=mod1, data=setData(X))
param.init <- list(theta1=1,theta=1)
low.par <- list(theta1=0,theta2=0)
upp.par <- list(theta1=1,theta2=1)
mle1 <- qmle(yuima , start=param.init, lower=low.par, upper=upp.par)
summary(mle1)
那很简单。也可以与对象一起使用，检查对象的一种属性。 喜欢，
V1 V2
1 4/28/2013 134.21
2 4/29/2013 144.54
3 4/30/2013 139.00
4 5/1/2013 116.99
5 5/2/2013 105.21
6 5/3/2013 97.75
答案 31 :(得分：2)
您可以使用underscore.js：http://underscorejs.org/#intersection
您需要数组的方法：
_.difference([1, 2, 3, 4, 5], [5, 2, 10]);
=> [1, 3, 4]
_.intersection([1, 2, 3], [101, 2, 1, 10], [2, 1]);
=> [1, 2]
答案 32 :(得分：2)
littlebit修复最佳答案
function arr_diff(a1, a2)
{
var a=[], diff=[];
for(var i=0;i<a1.length;i++)
a[a1[i]]=a1[i];
for(var i=0;i<a2.length;i++)
if(a[a2[i]]) delete a[a2[i]];
else a[a2[i]]=a2[i];
for(var k in a)
diff.push(a[k]);
return diff;
}
这将考虑当前类型的元素。 b / c当我们创建一个[a1 [i]]时，它将一个值从其oroginal值转换为string，所以我们失去了实际值。
答案 33 :(得分：1)
对称和线性复杂性。需要ES6。
function arrDiff(arr1, arr2) {
var arrays = [arr1, arr2].sort((a, b) => a.length - b.length);
var smallSet = new Set(arrays[0]);
return arrays[1].filter(x => !smallSet.has(x));
}
答案 34 :(得分：1)
另一个答案，但是似乎没有人提到jsperf，他们比较了几种算法和技术支持：https://jsperf.com/array-difference-javascript似乎使用过滤器可获得最佳结果。谢谢
答案 35 :(得分：1)
类似于Ian Grainger的解决方案（但在打字稿中）：
function findDiffs(arrayOne: string[], arrayTwo: string[]) {
let onlyInArrayOne = []
let onlyInArrayTwo = []
let share = []
let [arrayOneCopy, arrayTwoCopy] = [[...arrayOne], [...arrayTwo]]
arrayOneCopy.sort(); arrayTwoCopy.sort()
while (arrayOneCopy.length !== 0 && arrayTwoCopy.length !== 0) {
if (arrayOneCopy[0] == arrayTwoCopy[0]) {
share.push(arrayOneCopy[0])
arrayOneCopy.splice(0, 1)
arrayTwoCopy.splice(0, 1)
}
if (arrayOneCopy[0] < arrayTwoCopy[0]) {
onlyInArrayOne.push(arrayOneCopy[0])
arrayOneCopy.splice(0, 1)
}
if (arrayOneCopy[0] > arrayTwoCopy[0]) {
onlyInArrayTwo.push(arrayTwoCopy[0])
arrayTwoCopy.splice(0, 1)
}
}
onlyInArrayTwo = onlyInArrayTwo.concat(arrayTwoCopy)
onlyInArrayOne = onlyInArrayOne.concat(arrayOneCopy)
return {
onlyInArrayOne,
onlyInArrayTwo,
share,
diff: onlyInArrayOne.concat(onlyInArrayTwo)
}
}
// arrayOne: [ 'a', 'b', 'c', 'm', 'y' ]
// arrayTwo: [ 'c', 'b', 'f', 'h' ]
//
// Results:
// {
// onlyInArrayOne: [ 'a', 'm', 'y' ],
// onlyInArrayTwo: [ 'f', 'h' ],
// share: [ 'b', 'c' ],
// diff: [ 'a', 'm', 'y', 'f', 'h' ]
// }
答案 36 :(得分：1)
我同意@ luis-sieira的解决方案
我创建了一些自我解释功能，供初学者轻松逐步了解：
function difference(oneArr, twoArr){
var newArr = [];
newArr = oneArr.filter((item)=>{
return !twoArr.includes(item)
});
console.log(newArr)
let arr = twoArr.filter((item)=>{
return !oneArr.includes(item)
});
newArr = newArr.concat(arr);
console.log(newArr)
}
difference([1, 2, 3, 5], [1, 2, 3, 4, 5])
答案 37 :(得分：1)
function arrayDiff(a, b) {
return a.concat(b).filter(val => !(b.includes(val)));
//(or) return a.concat(b).filter(val => !(a.includes(val) && b.includes(val)));
}
答案 38 :(得分：1)
这是另一种可以返回差异的解决方案，就像 git diff 一样：（它是用打字稿编写的，如果您没有使用打字稿版本，只需删除类型即可）
/**
* util function to calculate the difference between two arrays (pay attention to 'from' and 'to'),
* it would return the mutations from 'from' to 'to'
* @param { T[] } from
* @param { T[] } to
* @returns { { [x in string]: boolean } } it would return the stringified version of array element, true means added,
* false means removed
*/
export function arrDiff<T>(from: T[], to: T[]): { [x in string]: boolean } {
var diff: { [x in string]: boolean } = {};
var newItems: T[] = []
diff = from.reduce((a, e) => ({ ...a, [JSON.stringify(e)]: true }), {})
for (var i = 0; i < to.length; i++) {
if (diff[JSON.stringify(to[i])]) {
delete diff[JSON.stringify(to[i])]
} else {
newItems.push(to[i])
}
}
return {
...Object.keys(diff).reduce((a, e) => ({ ...a, [e]: false }), {}),
...newItems.reduce((a, e) => ({ ...a, [JSON.stringify(e)]: true }), {})
}
}
以下是使用示例：
arrDiff(['a', 'b', 'c'], ['a', 'd', 'c', 'f']) //{"b": false, "d": true, "f": true}
答案 39 :(得分：1)
如果你想找到两个对象数组之间的差异，你可以这样做：
let arrObj = [{id: 1},{id: 2},{id: 3}]
let arrObj2 = [{id: 1},{id: 3}]
let result = arrObj.filter(x => arrObj2.every(x2 => x2.id !== x.id))
console.log(result)答案 40 :(得分：1)
只需比较所有值，并使用不重复的值返回数组。
var main = [9, '$', 'x', 'r', 3, 'A', '#', 0, 1];
var arr0 = ['Z', 9, 'e', '$', 'r'];
var arr1 = ['x', 'r', 3, 'A', '#'];
var arr2 = ['m', '#', 'a', 0, 'r'];
var arr3 = ['$', 1, 'n', '!', 'A'];
Array.prototype.diff = function(arrays) {
var items = [].concat.apply(this, arguments);
var diff = [].slice.call(items), i, l, x, pos;
// go through all items
for (x = 0, i = 0, l = items.length; i < l; x = 0, i++) {
// find all positions
while ((pos = diff.indexOf(items[i])) > -1) {
// remove item + increase found count
diff.splice(pos, 1) && x++;
}
// if item was found just once, put it back
if (x === 1) diff.push(items[i]);
}
// get all not duplicated items
return diff;
};
main.diff(arr0, arr1, arr2, arr3).join(''); // returns "Zeman!"
[].diff(main, arr0, arr1, arr2, arr3).join(''); // returns "Zeman!"
答案 41 :(得分：1)
我想要一个类似的函数，它接受了一个旧数组和一个新数组，并给了我一组添加的项目和一系列已删除的项目，我希望它有效（所以没有.contains！）。
您可以在此处使用我提出的解决方案：http://jsbin.com/osewu3/12。
任何人都可以看到该算法有任何问题/改进吗？谢谢！
代码清单：
function diff(o, n) {
// deal with empty lists
if (o == undefined) o = [];
if (n == undefined) n = [];
// sort both arrays (or this won't work)
o.sort(); n.sort();
// don't compare if either list is empty
if (o.length == 0 || n.length == 0) return {added: n, removed: o};
// declare temporary variables
var op = 0; var np = 0;
var a = []; var r = [];
// compare arrays and add to add or remove lists
while (op < o.length && np < n.length) {
if (o[op] < n[np]) {
// push to diff?
r.push(o[op]);
op++;
}
else if (o[op] > n[np]) {
// push to diff?
a.push(n[np]);
np++;
}
else {
op++;np++;
}
}
// add remaining items
if( np < n.length )
a = a.concat(n.slice(np, n.length));
if( op < o.length )
r = r.concat(o.slice(op, o.length));
return {added: a, removed: r};
}
答案 42 :(得分：1)
我正在寻找一个简单的答案，不涉及使用不同的库，我想出了我自己的，我认为这里没有提到过。 我不知道它有多高效或有效但是有效;
function find_diff(arr1, arr2) {
diff = [];
joined = arr1.concat(arr2);
for( i = 0; i <= joined.length; i++ ) {
current = joined[i];
if( joined.indexOf(current) == joined.lastIndexOf(current) ) {
diff.push(current);
}
}
return diff;
}
对于我的代码我也需要重复，但我想这并不总是首选。
我认为主要缺点是它可能会比较许多已被拒绝的选项。
答案 43 :(得分：1)
回应想要从另一个数据中减去一个数组的人......
如果不超过1000个元素试试这个......
设置一个新变量来复制Array01并将其命名为Array03。
现在，使用冒泡排序算法将Array01的元素与Array02进行比较，并在每次找到匹配时进行比较 执行以下操作到Array03 ...
if (Array01[x]==Array02[y]) {Array03.splice(x,1);}
注意：我们正在修改Array03而不是Array01，以免搞砸了冒泡排序的嵌套循环！
最后，使用简单的赋值将Array03的内容复制到Array01，然后就完成了。
答案 44 :(得分：1)
塞缪尔：“对于我的代码我也需要重复，但我想这并不总是首选。 我想主要的缺点是它可能会比较许多已被拒绝的选项。“
比较两个列表，数组等，并且元素小于1000，是行业标准中的 3GL世界是使用冒泡排序，避免欺骗。
代码看起来像这样......（未经测试但它应该有用）
var Array01=new Array('A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P');
var Array02=new Array('X','B','F','W','Z','X','J','P','P','O','E','N','Q');
var Array03=Array01;
for(x=1; x<Array02.length; x++) {
for(y=0; y<Array01.length-1; y++) {
if (Array01[y]==Array02[x]) {Array03.splice(y,1);}}}
Array01=Array03;
测试输出......
for(y=0; y<Array01.length; y++) {document.write(Array01[y])}
答案 45 :(得分：1)
如果不使用hasOwnProperty，那么我们有不正确的元素。例如：
[1,2,3].diff([1,2]); //Return ["3", "remove", "diff"] This is the wrong version
我的版本：
Array.prototype.diff = function(array2)
{
var a = [],
diff = [],
array1 = this || [];
for (var i = 0; i < array1.length; i++) {
a[array1[i]] = true;
}
for (var i = 0; i < array2.length; i++) {
if (a[array2[i]]) {
delete a[array2[i]];
} else {
a[array2[i]] = true;
}
}
for (var k in a) {
if (!a.hasOwnProperty(k)){
continue;
}
diff.push(k);
}
return diff;
}
答案 46 :(得分：1)
使用我目前正在使用的jQuery解决方案：
if (!Array.prototype.diff) {
Array.prototype.diff = function (a) {
return $.grep(this, function (i) { return $.inArray(i, a) === -1; });
};
}
答案 47 :(得分：1)
CoffeeScript版本：
diff = (val for val in array1 when val not in array2)
答案 48 :(得分：0)
如果您不关心原始数组，也没有编辑它们的问题，那么这是更快的算法：
let iterator = arrayA.values()
let result = []
for (entryA of iterator) {
if (!arrayB.includes(entryA)) {
result.push(entryA)
} else {
arrayB.splice(arrayB.indexOf(entryA), 1)
}
}
result.push(...arrayB)
return result
答案 49 :(得分：0)
以下是我使用的内容：
var newArr = a1.filter(function(elem) {
return a2.indexOf(elem) === -1;
}).concat( a2.filter(function(elem) {
return a1.indexOf(elem) === -1;
}));
console.log(newArr);
或者这个
var newArr = a1.concat(a2);
function check(item) {
if (a1.indexOf(item) === -1 || a2.indexOf(item) === -1) {
return item;
}
}
return newArr.filter(check);
答案 50 :(得分：0)
试试看。
var first = [ 1, 2, 3, 4, 5 ];
var second = [ 4, 5, 6 ];
var difference = first.filter(x => second.indexOf(x) === -1);
console.log(difference);
Output: [ 1, 2, 3]
答案 51 :(得分：0)
var arrayDifference = function(arr1, arr2){
if(arr1 && arr1.length){
if(arr2 && arr2.length > 0){
for (var i=0, itemIndex; i<arr2.length; i++){
itemIndex = arr1.indexOf(arr2[i]);
if(itemIndex !== -1){
arr1.splice(itemIndex, 1);
}
}
}
return arr1;
}
return [];
};
arrayDifference([1,2,3,4,5], [1,5,6]);
答案 52 :(得分：0)
艰难的方式（如果你想做一些比.indexOf更花哨的事情）
var difference = function (source, target) {
return source.reduce(function (diff, current) {
if (target.indexOf(current) === -1) {
diff.push(current);
}
return diff;
}, []);
}
简单方法
var difference = function (source, target) {
return source.filter(function (current) {
return target.indexOf(current) === -1;
});
}
答案 53 :(得分：0)
Cypress.env('db').password
答案 54 :(得分：0)
var compare = array1.length > array2.length ? array1 : array2;
var compareWith = array1.length > array2.length ? array2 : array1;
var uniqueValues = compareWith.filter(function(value){
if(compare.indexOf(vakye) == -1)
return true;
});
这将同时检查哪个是数组中较大的一个，然后进行比较。
答案 55 :(得分：0)
这里是经过稍微修改的版本，使用对象存储散列，可以处理数组中的数字和字符串。
function arrDiff(a, b) {
const hash = {};
a.forEach(n => { hash[n] = n; });
b.forEach(n => {
if (hash[n]) {
delete hash[n];
} else {
hash[n] = n;
}
});
return Object.values(hash);
}
答案 56 :(得分：0)
基于先前的答案...取决于您是否需要高效的或“不错的一体式”解决方案。
一般有3种方法...
-
“手动迭代”（使用indexOf）-天真，复杂度为O（n2）（慢）
var array_diff_naive = function(a,b){ var i, la = a.length, lb = b.length, res = []; if (!la) return b; else if (!lb) return a; for (i = 0; i < la; i++) { if (b.indexOf(a[i]) === -1) res.push(a[i]); } for (i = 0; i < lb; i++) { if (a.indexOf(b[i]) === -1) res.push(b[i]); } return res; } -
“抽象迭代”（使用过滤器和concat库方法）-用于手动迭代的语法糖（看起来更好，但仍然很烂）
var array_diff_modern = function(a1,a2){ return a1.filter(function(v) { return !a2.includes(v); } ) .concat(a2.filter(function(v) { return !a1.includes(v);})); } -
“使用哈希表”（使用对象键）-效率更高-仅O（n），但输入数组值的范围略有限制
var array_diff_hash = function(a1,a2){ var a = [], diff = []; for (var i = 0; i < a1.length; i++) { a[a1[i]] = true; } for (var i = 0; i < a2.length; i++) { if (a[a2[i]]) { delete a[a2[i]]; } else { a[a2[i]] = true; } } for (var k in a) { diff.push(k); } return diff; }
在jsperf上查看此内容
https://jsperf.com/array-diff-algo
答案 57 :(得分：0)
我在这里阅读的答案存在很多问题，这使得它们在实际编程应用中的价值有限。
首先，您将希望有一种方法来控制数组中两个项目“相等”的含义。 ===比较不会削减它，如果你试图找出是否根据ID或类似的东西更新对象数组，这坦率地说可能是你想要的最可能的场景之一差异功能。它还限制你可以与===运算符进行比较的数组，即字符串，整数等，这对成年人来说几乎是不可接受的。
其次，差异操作有三种状态结果：
- 第一个数组中但不在第二个数组中的元素
- 两个数组共有的元素
- 第二个数组中但不在第一个 中的元素
我认为这意味着你需要不少于2个循环，但是如果有人知道如何将它减少到一个，那么我会接受肮脏的技巧。
这是我拼凑在一起的东西，我想强调一点，我绝对不关心它在旧版本的Microshaft浏览器中不起作用。如果您在IE等劣质编码环境中工作，则由您自行修改，以便在您遇到的令人不满意的限制范围内工作。
Array.defaultValueComparison = function(a, b) {
return (a === b);
};
Array.prototype.diff = function(arr, fnCompare) {
// validate params
if (!(arr instanceof Array))
arr = [arr];
fnCompare = fnCompare || Array.defaultValueComparison;
var original = this, exists, storage,
result = { common: [], removed: [], inserted: [] };
original.forEach(function(existingItem) {
// Finds common elements and elements that
// do not exist in the original array
exists = arr.some(function(newItem) {
return fnCompare(existingItem, newItem);
});
storage = (exists) ? result.common : result.removed;
storage.push(existingItem);
});
arr.forEach(function(newItem) {
exists = original.some(function(existingItem) {
return fnCompare(existingItem, newItem);
});
if (!exists)
result.inserted.push(newItem);
});
return result;
};
答案 58 :(得分：0)
数据：
var new_storage = JSON.parse('[{"id_order":"0003"},{"id_order":"0004"},{"id_order":"0006"}]');
var old_storage = JSON.parse('[{"id_order":"0001"},{"id_order":"0002"},{"id_order":"0003"},{"id_order":"0004"},{"id_order":"0005"}]');
使用过滤器：
var diff = new_storage
.filter(x => {if(!(old_storage.filter(y => y.id_order==x.id_order)).length){return x}})
.concat(old_storage
.filter(x => {if(!(new_storage.filter(y => y.id_order==x.id_order)).length){return x}})
)
console.log(JSON.stringify(diff))
两个数组中的结果差异
[{"id_order":"0006"},{"id_order":"0001"},{"id_order":"0002"},{"id_order":"0005"}]
答案 59 :(得分：0)
基于Thinker's answer，但允许重复。
地图会按其显示的顺序递增地图值，如果它们在另一个数组中，则递减地图值。
任何剩余物都将包括在差额中。
function diff(curr, prev) {
let a = curr.split('').sort(), b = prev.split('').sort(), c = arrDiff(a, b);
console.log(JSON.stringify(a), '-', JSON.stringify(b), '=', JSON.stringify(c));
return c;
}
function arrDiff(larger, smaller) {
var entries = {};
for (var i = 0; i < larger.length; i++) {
entries[larger[i]] = (entries[larger[i]] || 0) + 1;
}
for (var i = 0; i < smaller.length; i++) {
if (entries[smaller[i]]) {
entries[smaller[i]] -= 1;
} else {
entries[smaller[i]] = (entries[smaller[i]] || 0) + 1;
}
}
return Object.keys(entries).sort().reduce((diff, key) => {
if (entries[key] > 0) {
for (var i = 0; i < entries[key]; i++) {
diff.push(key);
}
}
return diff;
}, []);
}
// Smaller is a subset of Larger
console.log('Result:', JSON.stringify(diff('ENLIGHTEN', 'LENGTHEN'))); // [ I ]
console.log('Result:', JSON.stringify(diff('STRENGTH', 'TENTHS'))); // [ G, R ]
// Both have a unique value
console.log('Result:', JSON.stringify(diff('BUBBLE', 'RUBBLE'))); // [ B, R ].as-console-wrapper { top: 0; max-height: 100% !important; }
答案 60 :(得分：0)
const difference = function (baseArray, arrayToCampare, callback = (a, b) => a!== b) {
if (!(arrayToCampare instanceof Array)) {
return baseArray;
}
return baseArray.filter(baseEl =>
arrayToCampare.every(compareEl => callback(baseEl, compareEl)));
}
答案 61 :(得分：0)
如果你的数组包含对象，那么如果你想比较属性就会变得有点困难。
幸运的是lodash使用_contains和_.pluck让这很容易：
var list1 = [{id: 1},{id: 2}];
var list1 = [{id: 1},{id: 2}, {id: 3}];
//es6
var results = list2.filter(item => {
return !_.contains(_.pluck(list1, 'id'), item.id);
});
//es5
var results = list2.filter(function(item){
return !_.contains(_.pluck(list1, 'id'), item.id);
});
//results contains [{id: 3}]
答案 62 :(得分：0)
var result = [];
var arr1 = [1,2,3,4];
var arr2 = [2,3];
arr1.forEach(function(el, idx) {
function unEqual(element, index, array) {
var a = el;
return (element!=a);
}
if (arr2.every(unEqual)) {
result.push(el);
};
});
alert(result);
答案 63 :(得分：0)
这个问题很老但是仍然是 javascript数组减法的热门话题，所以我想添加我正在使用的解决方案。这适用于以下情况：
var a1 = [1,2,2,3]
var a2 = [1,2]
//result = [2,3]
以下方法将产生所需的结果：
function arrayDifference(minuend, subtrahend) {
for (var i = 0; i < minuend.length; i++) {
var j = subtrahend.indexOf(minuend[i])
if (j != -1) {
minuend.splice(i, 1);
subtrahend.splice(j, 1);
}
}
return minuend;
}
应该注意的是，该函数不包括减数中不存在于减数中的值：
var a1 = [1,2,3]
var a2 = [2,3,4]
//result = [1]
答案 64 :(得分：0)
将其作为部分功能处理起来对我来说更容易。没看到功能性的编程解决方案，我感到非常惊讶，这是ES6中的我的问题：
const arrayDiff = (a, b) => {
return diff(b)(a);
}
const contains = (needle) => (array) => {
for (let i=0; i < array.length; i++) {
if (array[i] == needle) return true;
}
return false;
}
const diff = (compare) => {
return (array) => array.filter((elem) => !contains(elem)(compare))
}
答案 65 :(得分：0)
修剪字符串以确保....空格不会影响差异
function arr_diff(a1, a2) {
var a=[], diff=[];
for(var i=0;i<a1.length;i++)
a[a1[i]]=true;
for(var i=0;i<a2.length;i++)
if(a[a2[i].trim()]) delete a[a2[i].trim()];
else a[a2[i].trim()]=true;
for(var k in a)
diff.push(k);
return diff;
}
答案 66 :(得分：0)
**这将返回基于＆＃39;类型＆＃39;的任何2个数组的唯一值数组，或重复数组，或非重复数组（差异）数组。论点。 **
let json1 = ['one', 'two']
let json2 = ['one', 'two', 'three', 'four']
function uniq_n_shit (arr1, arr2, type) {
let concat = arr1.concat(arr2)
let set = [...new Set(concat)]
if (!type || type === 'uniq' || type === 'unique') {
return set
} else if (type === 'duplicate') {
concat = arr1.concat(arr2)
return concat.filter(function (obj, index, self) {
return index !== self.indexOf(obj)
})
} else if (type === 'not_duplicate') {
let duplicates = concat.filter(function (obj, index, self) {
return index !== self.indexOf(obj)
})
for (let r = 0; r < duplicates.length; r++) {
let i = set.indexOf(duplicates[r]);
if(i !== -1) {
set.splice(i, 1);
}
}
return set
}
}
console.log(uniq_n_shit(json1, json2, null)) // => [ 'one', 'two', 'three', 'four' ]
console.log(uniq_n_shit(json1, json2, 'uniq')) // => [ 'one', 'two', 'three', 'four' ]
console.log(uniq_n_shit(json1, json2, 'duplicate')) // => [ 'one', 'two' ]
console.log(uniq_n_shit(json1, json2, 'not_duplicate')) // => [ 'three', 'four' ]
答案 67 :(得分：0)
快速解决方案。虽然其他人似乎已经发布了相同方法的不同变体。我不确定这对于大型阵列是最好的，但它适用于我的阵列，它不会超过10或15。
差异 b - a
for(var i = 0; i < b.length; i++){
for(var j = 0; j < a.length; j ++){
var loc = b.indexOf(a[j]);
if(loc > -1){
b.splice(loc, 1);
}
}
}
答案 68 :(得分：0)
选择的答案只有一半。您必须通过两种方式比较数组以获得完整的答案。
const ids_exist = [
'1234',
'5678',
'abcd',
]
const ids_new = [
'1234',
'5678',
'efjk',
'9999',
]
function __uniq_Filter (__array_1, __array_2) {
const one_not_in_two = __array_1.filter(function (obj) {
return __array_2.indexOf(obj) == -1
})
const two_not_in_one = __array_2.filter(function (obj) {
return __array_1.indexOf(obj) == -1
})
return one_not_in_two.concat(two_not_in_one)
}
let uniq_filter = __uniq_Filter(ids_exist, ids_new)
console.log('uniq_filter', uniq_filter) // => [ 'abcd', 'efjk', '9999' ]
答案 69 :(得分：0)
您可以使用公共对象并计算第一个数组中每个值的频率。对于第二个数组，递减公共对象中的值。然后迭代所有键并添加值大于1的所有键。
＆＃13;
＆＃13;
＆＃13;
＆＃13;
const difference = (a1, a2) => {
var obj = {};
a1.forEach(v => obj[v] = (obj[v] || 0) + 1);
a2.forEach(v => obj[v] = (obj[v] || 0) - 1);
return Object
.keys(obj)
.reduce((r,k) => {
if(obj[k] > 0)
r = r.concat(Array.from({length: obj[k]}).fill(k));
return r;
},[]);
};
const result = difference(['a', 'a', 'b', 'c', 'd'], ['a', 'b']);
console.log(result);
答案 70 :(得分：0)
我已经尝试了以上所有这些但是当你需要匹配而没有接受重复时，没有一个工作。
例如：
var a1 = [1, 2, 1, 4], a2 = [1, 2, 4];
会返回一个空的diff数组，因为2会在第二个数组中找到一次，即使我们需要它匹配两次。
所以我设法解决了一些问题：
Array.prototype.diff = function(a) {
return this.filter(function(item) {
match = a.indexOf(item);
if (match)
a.splice(match, 1);
return match < 0;
});
};
答案 71 :(得分：0)
以下是我如何获得两个数组差异的方法。纯洁干净。
它将返回一个包含[add list]和[remove list]的对象。
function getDiff(past, now) {
let ret = { add: [], remove: [] };
for (var i = 0; i < now.length; i++) {
if (past.indexOf(now[i]) < 0)
ret['add'].push(now[i]);
}
for (var i = 0; i < past.length; i++) {
if (now.indexOf(past[i]) < 0)
ret['remove'].push(past[i]);
}
return ret;
}
答案 72 :(得分：0)
这是我用来获取2个数组之间差异的函数 - 它适用于数字，字符串，混合数字/字符串数组。不是数组/多维数组中的对象文字
function diff(arr1, arr2) {
var x,
t;
function uniq(a, b) {
t = b;
if( (b === 0 && x[b+1]!==a) ||
(t > 0 && a !== x[b+1] && a !== x[b-1]) ) {
return a;
}
}
x = arr1.concat(arr2).sort();
return x.filter(uniq);
}
var a1 = ['a', 'b', 'e', 'c'],
a2 = ['b', 'a', 'c', 'f' ];
diff(a1, a2);
答案 73 :(得分：0)
function array_diff(a, b) {
let array = [];
for(let i = 0; i <a.length; i++) {
let k = 0;
for( let j = 0; j < b.length; j++) {
if(a[i]!==b[j]) {
k++;
}
if(k===b.length) {
array = array.concat(a[i]);
}
}
if(b.length ===0) {
array = array.concat(a[i]);
}
}
return array;
}
答案 74 :(得分：-1)
我陷入了这个问题，这是为了得到两个简单数组的区别
var a1 = ['a', 'b'];
var a2 = ['a', 'b', 'c', 'd'];
// need ["c", "d"]
我不明白为什么不选择基本的for循环：
for(var i=0; i < a1.length; i++) {
for(var j=0; j < a2.length; j++) {
if(a1[i] == a2[j]) {
a2.splice(j, 1);
}
}
}
将返回所需的["c", "d"]
[编辑]正好在上面提出，看得太晚了。
无论如何，有什么理由可以避免这种简单的解决方案吗？
答案 75 :(得分：-1)
转换为字符串对象类型：
[1, 1].toString() === [1, 1].toString(); // true
相关问题
最新问题
- 我写了这段代码，但我无法理解我的错误
- 我无法从一个代码实例的列表中删除 None 值，但我可以在另一个实例中。为什么它适用于一个细分市场而不适用于另一个细分市场？
- 是否有可能使 loadstring 不可能等于打印？卢阿
- java中的random.expovariate()
- Appscript 通过会议在 Google 日历中发送电子邮件和创建活动
- 为什么我的 Onclick 箭头功能在 React 中不起作用？
- 在此代码中是否有使用“this”的替代方法？
- 在 SQL Server 和 PostgreSQL 上查询，我如何从第一个表获得第二个表的可视化
- 每千个数字得到
- 更新了城市边界 KML 文件的来源？