blocks|key|1493869|text|在这种情况下，您可以使用Set。它针对这种操作(并集、交集、差分)进行了优化。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1493870|确保它适用于您的案例，一旦它不允许重复。|1493871|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}|code-block|syntax|javascript|1493872|entityMap|0|LINK|mutability|MUTABLE|url|http://jsclass.jcoglan.com/set.html^0|C|3|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

You could use a <a href="http://jsclass.jcoglan.com/set.html" rel="noreferrer">Set</a> in this case. It is optimized for this kind of operation (union, intersection, difference).

Make sure it applies to your case, once it allows no duplicates.

<pre><code>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)
// -&gt; Set{1,3,5,7,9}
</code></pre>

blocks|key|1279082|text|只是在想。为了挑战;-)这会有效吗？(用于字符串、数字等的基本数组)无嵌套数组|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1279083|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%2B%2B){
++++key+=+bigArray[i];
++++test[key]+=+true;
++}
++if(!returnUnion){
++++//diffing
++++for(var+i=0;i<smallArray.length;i%2B%2B){
++++++key+=+smallArray[i];
++++++if(!test[key]){
++++++++test[key]+=+null;
++++++}
++++}
++}+else+{
++++//union
++++for(var+i=0;i<smallArray.length;i%2B%2B){
++++++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"]|code-block|syntax|javascript|1279084|注意排序可能不会像上面提到的那样...但如果需要，可以在数组上调用.sort()对其进行排序。|1279085|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Just thinking... for the sake of a challenge ;-) would this work... (for basic arrays of strings, numbers, etc.) no nested arrays

<pre><code>function diffArrays(arr1, arr2, returnUnion){
 var ret = [];
 var test = {};
 var bigArray, smallArray, key;
 if(arr1.length &gt;= arr2.length){
 bigArray = arr1;
 smallArray = arr2;
 } else {
 bigArray = arr2;
 smallArray = arr1;
 }
 for(var i=0;i&lt;bigArray.length;i++){
 key = bigArray[i];
 test[key] = true;
 }
 if(!returnUnion){
 //diffing
 for(var i=0;i&lt;smallArray.length;i++){
 key = smallArray[i];
 if(!test[key]){
 test[key] = null;
 }
 }
 } else {
 //union
 for(var i=0;i&lt;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"]
</code></pre>

Note the sorting will likely not be as noted above... but if desired, call .sort() on the array to sort it.

blocks|key|1493925|text|这样如何：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1493926|Array.prototype.contains+=+function(needle){
++for+(var+i=0;+i<this.length;+i%2B%2B)
++++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));|code-block|syntax|javascript|1493927|这样你就可以通过array1.diff(array2)得到它们之间的差异(我相信算法的时间复杂度是-+O(array1.length+x+array2.length)+)|offset|length|style|CODE|1493928|entityMap^0|0|0|8|J|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

How about this:

<pre><code>Array.prototype.contains = function(needle){
 for (var i=0; i&lt;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));
</code></pre>

So this way you can do <code>array1.diff(array2)</code> to get their difference (Horrible time complexity for the algorithm though - O(array1.length x array2.length) I believe)

blocks|key|1493958|text|我想要一个类似的函数，它接受一个旧的数组和一个新的数组，并给我一个添加项的数组和一个删除项的数组，我希望它是高效的(所以没有.contains!)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1493959|您可以在这里试用我提出的解决方案：http://jsbin.com/osewu3/12。|offset|length|1493960|有人能看到该算法的任何问题/改进吗？谢谢!|1493961|代码清单：|1493962|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+%7C%7C+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%2B%2B;
++++++}
++++++else+if+(o[op]+>+n[np])+{
++++++++++//+push+to+diff?
++++++++++a.push(n[np]);
++++++++++np%2B%2B;
++++++}
++++++else+{
++++++++++op%2B%2B;np%2B%2B;
++++++}
++}

++//+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};+
}|code-block|syntax|javascript|1493963|entityMap|0|LINK|mutability|MUTABLE|url|http://jsbin.com/osewu3/12^0|0|H|Q|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@$D|Y|E|Z|1|10]]|A|$]]|$1|F|3|G|5|6|7|11|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|12|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|13|8|@]|9|@]|A|$M|N]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

I wanted a similar function which took in an old array and a new array and gave me an array of added items and an array of removed items, and I wanted it to be efficient (so no .contains!).

You can play with my proposed solution here: <a href="http://jsbin.com/osewu3/12" rel="nofollow noreferrer">http://jsbin.com/osewu3/12</a>.

Can anyone see any problems/improvements to that algorithm? Thanks!

Code listing:

<pre><code>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 &lt; o.length &amp;&amp; np &lt; n.length) {
 if (o[op] &lt; n[np]) {
 // push to diff?
 r.push(o[op]);
 op++;
 }
 else if (o[op] &gt; n[np]) {
 // push to diff?
 a.push(n[np]);
 np++;
 }
 else {
 op++;np++;
 }
 }

 // add remaining items
 if( np &lt; n.length )
 a = a.concat(n.slice(np, n.length));
 if( op &lt; o.length )
 r = r.concat(o.slice(op, o.length));

 return {added: a, removed: r}; 
}
</code></pre>

blocks|key|1279200|text|使用http://phrogz.net/JS/ArraySetMath.js，您可以：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1279201|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"]|code-block|syntax|javascript|1279202|entityMap|0|LINK|mutability|MUTABLE|url|http://phrogz.net/JS/ArraySetMath.js^0|2|10|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Using <a href="http://phrogz.net/JS/ArraySetMath.js" rel="nofollow">http://phrogz.net/JS/ArraySetMath.js</a> you can:

<pre><code>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"]
</code></pre>

blocks|key|1279253|text|我正在寻找一个简单的答案，不涉及使用不同的库，我想出了我自己的答案，我认为这里没有提到。我不知道它的效率有多高，但它是有效的；|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1279254|++++function+find_diff(arr1,+arr2)+{
++++++diff+=+[];
++++++joined+=+arr1.concat(arr2);
++++++for(+i+=+0;+i+<=+joined.length;+i%2B%2B+)+{
++++++++current+=+joined[i];
++++++++if(+joined.indexOf(current)+==+joined.lastIndexOf(current)+)+{
++++++++++diff.push(current);
++++++++}
++++++}
++++++return+diff;
++++}|code-block|syntax|javascript|1279255|对于我的代码，我也需要去掉重复的东西，但我猜这并不总是首选的。|1279256|我猜主要的缺点是它潜在地比较了许多已经被拒绝的选项。|1279257|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I was looking for a simple answer that didn't involve using different libraries, and I came up with my own that I don't think has been mentioned here.
I don't know how efficient it is or anything but it works;

<pre><code> function find_diff(arr1, arr2) {
 diff = [];
 joined = arr1.concat(arr2);
 for( i = 0; i &lt;= joined.length; i++ ) {
 current = joined[i];
 if( joined.indexOf(current) == joined.lastIndexOf(current) ) {
 diff.push(current);
 }
 }
 return diff;
 }
</code></pre>

For my code I need duplicates taken out as well, but I guess that isn't always preferred.

I guess the main downside is it's potentially comparing many options that have already been rejected.

blocks|key|1279299|text|为了回应那些想要从一个数组中减去另一个数组的人...|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1279300|如果不超过1000个元素尝试这样做...|1279301|设置一个新变量来复制Array01并将其命名为Array03。|1279302|现在，使用冒泡排序算法将Array01的元素与Array02进行比较，只要找到匹配的元素，就对Array03执行以下操作...|1279303|+if+(Array01[x]==Array02[y])+{Array03.splice(x,1);}|code-block|syntax|javascript|1279304|注意:我们正在修改Array03而不是Array01，这样就不会搞砸冒泡排序的嵌套循环！|1279305|最后，通过一个简单的赋值将Array03的内容复制到Array01，就完成了。|1279306|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|U|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|V|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|W|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

In response to the person who wanted to subtract one array from another...

If no more than say 1000 elements try this...

Setup a new variable to duplicate Array01 and call it Array03.

Now, use the bubble sort algorithm to compare the elements of Array01 with Array02 and whenever you find a match
do the following to Array03...

<pre><code> if (Array01[x]==Array02[y]) {Array03.splice(x,1);}
</code></pre>

NB: We are modifying Array03 instead of Array01 so as not to screw up the nested loops of the bubble sort!

Finally, copy the contents of Array03 to Array01 with a simple assignment, and you're done.

blocks|key|1494197|text|Samuel：“对于我的代码，我也需要去掉重复的代码，但我猜这并不总是首选的。我猜主要的缺点是它可能会比较许多已经被拒绝的选项。”|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1494198|当比较两个列表、数组等并且元素小于1000时，3GL世界中的行业标准是使用冒泡排序，以避免被欺骗。|1494199|代码应该是这样的……(未经测试，但它应该可以工作)|1494200|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%2B%2B)+{
+for(y=0;+y<Array01.length-1;+y%2B%2B)+{
++if+(Array01[y]==Array02[x])+{Array03.splice(y,1);}}}

Array01=Array03;|code-block|syntax|javascript|1494201|要测试输出...|1494202|for(y=0;+y<Array01.length;+y%2B%2B)+{document.write(Array01[y])}|1494203|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|S|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|T|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|V|8|@]|9|@]|A|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Samuel: "For my code I need duplicates taken out as well, but I guess that isn't always preferred.
I guess the main downside is it's potentially comparing many options that have already been rejected."

When comparing TWO lists, Arrays, etc, and the elements are less than 1000, the industry standard in the
3GL world is to use the bubble sort which avoids dupes. 

The code would look something like this... (untested but it should work)

<pre><code>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&lt;Array02.length; x++) {
 for(y=0; y&lt;Array01.length-1; y++) {
 if (Array01[y]==Array02[x]) {Array03.splice(y,1);}}}

Array01=Array03;
</code></pre>

To test the output...

<pre><code>for(y=0; y&lt;Array01.length; y++) {document.write(Array01[y])}
</code></pre>

blocks|key|1494249|text|要从一个数组中减去另一个数组，只需使用下面的代码片段：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1494250|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;
});|code-block|syntax|javascript|1494251|它将返回“1”、“2”、“6”，它们是第一个数组中不存在于第二个数组中的项。|1494252|因此，根据您的问题示例，以下代码是确切的解决方案：|1494253|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;
});|1494254|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

to subtract one array from another, simply use the snippet below:

<pre><code>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) &lt; 0;
});
</code></pre>

It will returns ['1,'2','6'] that are items of first array which don't exist in the second.

Therefore, according to your problem sample, following code is the exact solution:

<pre><code>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) &lt; 0;
});
</code></pre>

blocks|key|1494293|text|为最佳答案做了一些小调整|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1494294|function+arr_diff(a1,+a2)
{
++var+a=[],+diff=[];
++for(var+i=0;i<a1.length;i%2B%2B)
++++a[a1[i]]=a1[i];
++for(var+i=0;i<a2.length;i%2B%2B)
++++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;
}|code-block|syntax|javascript|1494295|这将考虑当前元素的类型。b/c当我们创建a[a1i]时，它将一个值从它的原始值转换为字符串，因此我们丢失了实际值。|1494296|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

littlebit fix for the best answer

<pre><code>function arr_diff(a1, a2)
{
 var a=[], diff=[];
 for(var i=0;i&lt;a1.length;i++)
 a[a1[i]]=a1[i];
 for(var i=0;i&lt;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;
}
</code></pre>

this will take current type of element in consideration. b/c when we make a[a1[i]] it converts a value to string from its oroginal value, so we lost actual value.

blocks|key|1494334|text|对于小的数组，使用indexOf()的解决方案是可以的，但是随着它们长度的增长，算法的性能接近O(n%5E2)。这里有一个解决方案，通过使用对象作为关联数组来将数组条目存储为键，它将对非常大的数组执行得更好；它还可以自动消除重复条目，但只适用于字符串值(或可以安全存储为字符串的值)：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1494335|function+arrayDiff(a1,+a2)+{
++var+o1={},+o2={},+diff=[],+i,+len,+k;
++for+(i=0,+len=a1.length;+i<len;+i%2B%2B)+{+o1[a1[i]]+=+true;+}
++for+(i=0,+len=a2.length;+i<len;+i%2B%2B)+{+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']|code-block|syntax|javascript|1494336|entityMap^0|9|9|1B|6|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

A solution using <code>indexOf()</code> will be ok for small arrays but as they grow in length the performance of the algorithm approaches <code>O(n^2)</code>. Here's a solution that will perform better for very large arrays by using objects as associative arrays to store the array entries as keys; it also eliminates duplicate entries automatically but only works with string values (or values which can be safely stored as strings):

<pre class="lang-javascript prettyprint-override"><code>function arrayDiff(a1, a2) {
 var o1={}, o2={}, diff=[], i, len, k;
 for (i=0, len=a1.length; i&lt;len; i++) { o1[a1[i]] = true; }
 for (i=0, len=a2.length; i&lt;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); // =&gt; ['c', 'd']
arrayDiff(a2, a1); // =&gt; ['c', 'd']
</code></pre>

blocks|key|1279637|text|The+difference+method+in+Underscore+(或者它的替代产品，Lo-Dash)也可以做到这一点：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1279638|(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]|code-block|syntax|javascript|1279639|与任何下划线函数一样，您也可以在更面向对象的样式中使用它：|1279640|_([1,+2,+3,+4,+5]).difference([5,+2,+10]);|1279641|entityMap|0|LINK|mutability|MUTABLE|url|http://underscorejs.org/#difference|1|https://github.com/lodash/lodash/^0|0|Z|0|1A|7|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]|$A|10|B|11|1|12]]|C|$]]|$1|D|3|E|5|F|7|13|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|14|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|15|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|16|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]|U|$5|P|Q|R|C|$S|V]]]]

<a href="http://underscorejs.org/#difference">The difference method in Underscore</a> (or its drop-in replacement, <a href="https://github.com/lodash/lodash/">Lo-Dash</a>) can do this too:

<pre><code>(R)eturns the values from array that are not present in the other arrays

_.difference([1, 2, 3, 4, 5], [5, 2, 10]);
=&gt; [1, 3, 4]
</code></pre>

As with any Underscore function, you could also use it in a more object-oriented style:

<pre><code>_([1, 2, 3, 4, 5]).difference([5, 2, 10]);
</code></pre>

blocks|key|1279678|text|您可以使用underscore.js：http://underscorejs.org/#intersection|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1279679|您需要用于数组的方法：|1279680|_.difference([1,+2,+3,+4,+5],+[5,+2,+10]);
=>+[1,+3,+4]

_.intersection([1,+2,+3],+[101,+2,+1,+10],+[2,+1]);
=>+[1,+2]|code-block|syntax|javascript|1279681|entityMap|0|LINK|mutability|MUTABLE|url|http://underscorejs.org/#intersection^0|J|11|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

You can use underscore.js : <a href="http://underscorejs.org/#intersection" rel="nofollow">http://underscorejs.org/#intersection</a>

You have needed methods for array : 

<pre><code>_.difference([1, 2, 3, 4, 5], [5, 2, 10]);
=&gt; [1, 3, 4]

_.intersection([1, 2, 3], [101, 2, 1, 10], [2, 1]);
=&gt; [1, 2]
</code></pre>

blocks|key|1494572|text|这是到目前为止获得您想要的结果的最简单的方法，使用jQuery：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1494573|var+diff+=+$(old_array).not(new_array).get();|code-block|syntax|javascript|1494574|diff现在包含了old_array中不包含在new_array中的内容|offset|length|style|CODE|1494575|entityMap^0|0|0|0|4|9|9|N|9|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]|$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|N|$]]

This is by far the easiest way to get exactly the result you are looking for, using jQuery:

<pre><code>var diff = $(old_array).not(new_array).get();
</code></pre>

<code>diff</code> now contains what was in <code>old_array</code> that is not in <code>new_array</code>

blocks|key|1494605|text|如果不使用hasOwnProperty，那么我们就有不正确的元素。例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1494606|[1,2,3].diff([1,2]);+//Return+["3",+"remove",+"diff"]+This+is+the+wrong+version|code-block|syntax|javascript|1494607|我的版本：|1494608|Array.prototype.diff+=+function(array2)
++{
++++var+a+=+[],
++++++++diff+=+[],
++++++++array1+=+this+%7C%7C+[];

++++for+(var+i+=+0;+i+<+array1.length;+i%2B%2B)+{
++++++a[array1[i]]+=+true;
++++}
++++for+(var+i+=+0;+i+<+array2.length;+i%2B%2B)+{
++++++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;
++}|1494609|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

If not use hasOwnProperty then we have incorrect elements. For example: 

<pre><code>[1,2,3].diff([1,2]); //Return ["3", "remove", "diff"] This is the wrong version
</code></pre>

My version:

<pre><code>Array.prototype.diff = function(array2)
 {
 var a = [],
 diff = [],
 array1 = this || [];

 for (var i = 0; i &lt; array1.length; i++) {
 a[array1[i]] = true;
 }
 for (var i = 0; i &lt; 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;
 }
</code></pre>

blocks|key|1279846|text|我遇到了这个问题，那就是得到两个简单数组的差异|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1279847|var+a1+=+['a',+'b'];
var+a2+=+['a',+'b',+'c',+'d'];

//+need+["c",+"d"]|code-block|syntax|javascript|1279848|我不明白为什么不使用基本的for循环：|1279849|for(var+i=0;+i+<+a1.length;+i%2B%2B)+{
++for(var+j=0;+j+<+a2.length;+j%2B%2B)+{
++++if(a1[i]+==+a2[j])+{
++++++a2.splice(j,+1);
++++}
++}
}|1279850|它将返回所需的["c",+"d"]|offset|length|style|CODE|1279851|在上面编辑建议，看起来很晚了。|1279852|无论如何，有什么好的理由来避免这个简单的解决方案吗？|1279853|entityMap^0|0|0|0|0|7|A|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|10|8|@$M|11|N|12|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|14|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

I fall into this question, which was to get the difference of two simple arrays

<pre><code>var a1 = ['a', 'b'];
var a2 = ['a', 'b', 'c', 'd'];

// need ["c", "d"]
</code></pre>

and I don't see why not go with the basic for loops :

<pre><code>for(var i=0; i &lt; a1.length; i++) {
 for(var j=0; j &lt; a2.length; j++) {
 if(a1[i] == a2[j]) {
 a2.splice(j, 1);
 }
 }
}
</code></pre>

which would return the needed <code>["c", "d"]</code>

[edit] proposed right above, seen to late.

Anyway, any good reason to avoid this simple solution ?

blocks|key|1494695|text|使用我目前正在使用的jQuery解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1494696|if+(!Array.prototype.diff)+{
++++Array.prototype.diff+=+function+(a)+{
++++++++return+$.grep(this,+function+(i)+{+return+$.inArray(i,+a)+===+-1;+});
++++};+
}|code-block|syntax|javascript|1494697|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Contributing with a jQuery solution that I'm currently using:

<pre><code>if (!Array.prototype.diff) {
 Array.prototype.diff = function (a) {
 return $.grep(this, function (i) { return $.inArray(i, a) === -1; });
 }; 
}
</code></pre>

blocks|key|1494728|text|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);|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1494729|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>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);
</code></pre>

blocks|key|1494756|text|这是受到Thinker公认答案的启发，但Thinker的答案似乎假设数组是集合。如果数组是[+"1",+"2"+]和[+"1",+"1",+"2",+"2"+]，它就会崩溃|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1494757|这些数组之间的区别是[+"1",+"2"+]。下面的解决方案是O(n*n)，所以不是很理想，但是如果你有大的数组，它也比Thinker的解决方案有内存优势。|1494758|如果你首先处理的是集合，Thinker的解决方案肯定会更好。如果你有一个可以访问过滤器的更新版本的Javascript，你也应该使用这些。这只适用于那些不处理sets而使用旧版本JavaScript的人(不管是什么原因)……|1494759|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)+%7C%7C+(!Array.prototype.isPrototypeOf(array)))+{+
++++++++++++return+this.slice(0);
++++++++}

++++++++var+diff+=+[];
++++++++var+original+=+this.slice(0);

++++++++for(var+i=0;+i+<+array.length;+%2B%2Bi)+{
++++++++++++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;+%2B%2Bi)+{
++++++++++++diff.push(original[i]);
++++++++}
++++++++return+diff;
++++}
}+++|code-block|syntax|javascript|1494760|entityMap^0|19|C|1M|M|0|A|C|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|Y|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|Z|8|@]|D|@]|E|$M|N]]|$1|O|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|P|$]]

This was inspired by the accepted answer by Thinker, but Thinker's answer seems to assume the arrays are sets. It falls apart if the arrays are <code>[ "1", "2" ]</code> and <code>[ "1", "1", "2", "2" ]</code>

The difference between those arrays is <code>[ "1", "2" ]</code>. The following solution is O(n*n), so not ideal, but if you have big arrays, it has memory advantages over Thinker's solution as well. 

If you're dealing with sets in the first place, Thinker's solution is definitely better. If you have a newer version of Javascript with access to filters, you should use those as well. This is only for those who aren't dealing with sets and are using an older version of JavaScript (for whatever reason)...

<pre><code>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 &lt; array.length; ++i) {
 var index = original.indexOf(array[i]);
 if (index &gt; -1) { 
 original.splice(index, 1);
 } else { 
 diff.push(array[i]);
 }
 }

 for (var i=0; i &lt; original.length; ++i) {
 diff.push(original[i]);
 }
 return diff;
 }
} 
</code></pre>

blocks|key|1279975|text|只是修剪一下字符串以确保....空格不会影响差异|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1279976|function+arr_diff(a1,+a2)+{
++++var+a=[],+diff=[];
++++for(var+i=0;i<a1.length;i%2B%2B)
++++++++a[a1[i]]=true;
++++for(var+i=0;i<a2.length;i%2B%2B)
++++++++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;
}|code-block|syntax|javascript|1279977|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

just trimming the string to ensure.... spaces wont affect the diff

<pre><code>function arr_diff(a1, a2) {
 var a=[], diff=[];
 for(var i=0;i&lt;a1.length;i++)
 a[a1[i]]=true;
 for(var i=0;i&lt;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;
}
</code></pre>

blocks|key|1280029|text|上面这些我都试过了，但是当你需要在不接受重复的情况下进行匹配时，它们都不起作用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1280030|例如：|1280031|var+a1+=+[1,+2,+1,+4],+a2+=+[1,+2,+4];|code-block|syntax|javascript|1280032|将返回一个空的diff数组，因为2将在第二个数组中找到一次，即使我们需要它匹配两次。|offset|length|style|CODE|1280033|所以我设法解决了一些问题：|1280034|Array.prototype.diff+=+function(a)+{
++++return+this.filter(function(item)+{
++++++++match+=+a.indexOf(item);
++++++++if+(match)
++++++++++++a.splice(match,+1);
++++++++return+match+<+0;
++++});
};|1280035|entityMap^0|0|0|0|G|1|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|X|8|@$K|Y|L|Z|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|11|8|@]|9|@]|A|$G|H]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

I've tried all of these above but none worked when you needed to match without accepting duplicates.

For example:

<pre><code>var a1 = [1, 2, 1, 4], a2 = [1, 2, 4];
</code></pre>

Would return an empty diff array because <code>2</code> would be found once in the second array, even though we need it to match twice.

So I've managed to fix something up:

<pre><code>Array.prototype.diff = function(a) {
 return this.filter(function(item) {
 match = a.indexOf(item);
 if (match)
 a.splice(match, 1);
 return match &lt; 0;
 });
};
</code></pre>

blocks|key|1494891|text|下面是我用来计算两个数组之间差异的函数--它适用于数值、字符串、数字/字符串混合数组。数组/多维数组中的非对象文字|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1494892|function+diff(arr1,+arr2)+{

++++var+x,+
++++++++t;

++++function+uniq(a,+b)+{
++++++++t+=+b;

++++++++if(+(b+===+0+&&+x[b%2B1]!==a)+%7C%7C+
+++++++++++(t+>+0+&&+a+!==+x[b%2B1]+&&+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);|code-block|syntax|javascript|1494893|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

here's the function I use to get the difference between 2 arrays - It's good for numerical, string, mixed num/string arrays. not object literal within arrays / multidimentional arrays

<pre><code>function diff(arr1, arr2) {

 var x, 
 t;

 function uniq(a, b) {
 t = b;

 if( (b === 0 &amp;&amp; x[b+1]!==a) || 
 (t &gt; 0 &amp;&amp; a !== x[b+1] &amp;&amp; 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);
</code></pre>

blocks|key|1494939|text|随着带有sets和splat操作符的ES6的到来(当时它只在火狐中起作用，请检查compatibility+table)，您可以编写以下一行代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1494940|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)))];|code-block|syntax|javascript|1494941|这将导致[+"c",+"d"+]。|style|CODE|1494942|entityMap|0|LINK|mutability|MUTABLE|url|http://kangax.github.io/es5-compat-table/es6/^0|14|J|0|0|0|4|C|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@$A|10|B|11|K|L]]|9|@]|C|$]]|$1|M|3|-4|5|6|7|12|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

With the arrival of ES6 with sets and splat operator (at the time of being works only in Firefox, check <a href="http://kangax.github.io/es5-compat-table/es6/" rel="noreferrer">compatibility table</a>), you can write the following one liner:
<pre><code>var a = ['a', 'b', 'c', 'd'];
var b = ['a', 'b'];
var b1 = new Set(b);
var difference = [...new Set(a.filter(x =&gt; !b1.has(x)))];
</code></pre>
which will result in <code>[ &quot;c&quot;, &quot;d&quot; ]</code>.

blocks|key|1494951|text|CoffeeScript版本：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1494952|diff+=+(val+for+val+in+array1+when+val+not+in+array2)|code-block|syntax|javascript|1494953|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

CoffeeScript version:

<pre><code>diff = (val for val in array1 when val not in array2)
</code></pre>

blocks|key|1494995|text|如果你的数组包含对象，如果你想比较一个属性，就会变得有点困难。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1494996|幸运的是，使用_contains和_.pluck，lodash让这件事变得非常容易|offset|length|style|CODE|1494997|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}]|code-block|syntax|javascript|1494998|entityMap^0|0|7|9|H|7|P|6|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@$D|Q|E|R|F|G]|$D|S|E|T|F|G]|$D|U|E|V|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|W|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|N|$]]

If you're array contains objects it becomes a bit more difficult if you want to compare an attribute.

Luckily <code>lodash</code> makes this pretty easy using <code>_contains</code> and <code>_.pluck</code>:

<pre><code>var list1 = [{id: 1},{id: 2}];
var list1 = [{id: 1},{id: 2}, {id: 3}];

//es6
var results = list2.filter(item =&gt; {
 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}]
</code></pre>

blocks|key|1280250|text|function+diff(a1,+a2)+{
++return+a1.concat(a2).filter(function(val,+index,+arr){
++++return+arr.indexOf(val)+===+arr.lastIndexOf(val);
++});
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1280251|合并这两个数组，唯一值将只出现一次，因此indexOf()将与lastIndexOf()相同。|unstyled|1280252|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>function diff(a1, a2) {
 return a1.concat(a2).filter(function(val, index, arr){
 return arr.indexOf(val) === arr.lastIndexOf(val);
 });
}
</code></pre>

Merge both the arrays, unique values will appear only once so indexOf() will be the same as lastIndexOf().

blocks|key|1495059|text|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]|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1495060|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>Array.prototype.difference = function(e) {
 return this.filter(function(i) {return e.indexOf(i) &lt; 0;});
};

eg:- 

[1,2,3,4,5,6,7].difference( [3,4,5] ); 
 =&gt; [1, 2, 6 , 7]
</code></pre>

blocks|key|1280304|text|这是有效的:基本上合并两个数组，查找重复项，并将未复制的项推送到新数组中，这就是不同之处。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1280305|​|1280306|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%2B%2B){
++++++if(arr[j]+===+f){
++++++++t%2B%2B;+
++++++++}
++++}
++++if+(t+===+1){
++++++newArr.push(f);
++++++++}
++}+
++return+newArr;
}|code-block|syntax|javascript|1280307|1280308|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

This is working: basically merge the two arrays, look for the duplicates and push what is not duplicated into a new array which is the difference.

<div class="snippet" data-lang="js" data-hide="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>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&lt;arr.length; j++){
 if(arr[j] === f){
 t++; 
 }
 }
 if (t === 1){
 newArr.push(f);
 }
 } 
 return newArr;
}</code></pre>
</div>
</div>

blocks|key|1280340|text|强制转换为字符串对象类型：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1280341|[1,+1].toString()+===+[1,+1].toString();+//+true|code-block|syntax|javascript|1280342|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Cast to string object type:


<pre><code>[1, 1].toString() === [1, 1].toString(); // true
</code></pre>

blocks|key|1495187|text|简单地比较所有值，并返回数组和不重复的值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1495188|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%2B%2B)+{
++++++++//+find+all+positions
++++++++while+((pos+=+diff.indexOf(items[i]))+>+-1)+{
++++++++++++//+remove+item+%2B+increase+found+count
++++++++++++diff.splice(pos,+1)+&&+x%2B%2B;
++++++++}
++++++++//+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!"|code-block|syntax|javascript|1495189|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Simply compares all values and returns array with the values that do not repeat.

<pre><code>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 &lt; l; x = 0, i++) {
 // find all positions
 while ((pos = diff.indexOf(items[i])) &gt; -1) {
 // remove item + increase found count
 diff.splice(pos, 1) &amp;&amp; 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!"
</code></pre>

blocks|key|1280407|text|下面是我使用的代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1280408|var+newArr+=+a1.filter(function(elem)+{
++++++++++++return+a2.indexOf(elem)+===+-1;
++++++++}).concat(+a2.filter(function(elem)+{
++++++++++++return+a1.indexOf(elem)+===+-1;
++++++++}));
console.log(newArr);|code-block|syntax|javascript|1280409|或者是这个|1280410|var+newArr+=+a1.concat(a2);
++++++++function+check(item)+{
++++++++++++if+(a1.indexOf(item)+===+-1+%7C%7C+a2.indexOf(item)+===+-1)+{
++++++++++++++++return+item;
++++++++++++}
++++++++}
++++++++return+newArr.filter(check);|1280411|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Here is what I use:

<pre><code>var newArr = a1.filter(function(elem) {
 return a2.indexOf(elem) === -1;
 }).concat( a2.filter(function(elem) {
 return a1.indexOf(elem) === -1;
 }));
console.log(newArr);
</code></pre>

or this one

<pre><code>var newArr = a1.concat(a2);
 function check(item) {
 if (a1.indexOf(item) === -1 || a2.indexOf(item) === -1) {
 return item;
 }
 }
 return newArr.filter(check);
</code></pre>

blocks|key|1495210|text|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]|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1495211|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>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]
</code></pre>

blocks|key|1495280|text|function+diffArray(arr1,+arr2)+{
++var+newArr+=+arr1.concat(arr2);
++return+newArr.filter(function(i){
++++return+newArr.indexOf(i)+==+newArr.lastIndexOf(i);
++});
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1495281|这个很适合我|unstyled|1495282|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>function diffArray(arr1, arr2) {
 var newArr = arr1.concat(arr2);
 return newArr.filter(function(i){
 return newArr.indexOf(i) == newArr.lastIndexOf(i);
 });
}
</code></pre>

this is works for me

blocks|key|1495303|text|var+arrayDifference+=+function(arr1,+arr2){
++if(arr1+&&+arr1.length){
++++if(arr2+&&+arr2.length+>+0){
++++++for+(var+i=0,+itemIndex;+i<arr2.length;+i%2B%2B){
++++++++itemIndex+=+arr1.indexOf(arr2[i]);
++++++++if(itemIndex+!==+-1){
++++++++++arr1.splice(itemIndex,+1);
++++++++}
++++++}
++++}
++++return+arr1;
++}
++return+[];
};

arrayDifference([1,2,3,4,5],+[1,5,6]);|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1495304|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>var arrayDifference = function(arr1, arr2){
 if(arr1 &amp;&amp; arr1.length){
 if(arr2 &amp;&amp; arr2.length &gt; 0){
 for (var i=0, itemIndex; i&lt;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]);
</code></pre>

blocks|key|1495361|text|另一种解决问题的方法|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1495362|function+diffArray(arr1,+arr2)+{
++++return+arr1.concat(arr2).filter(function+(val)+{
++++++++if+(!(arr1.includes(val)+&&+arr2.includes(val)))
++++++++++++return+val;
++++});
}

diffArray([1,+2,+3,+7],+[3,+2,+1,+4,+5]);++++//+return+[7,+4,+5]|code-block|syntax|javascript|1495363|此外，您还可以使用箭头函数语法：|1495364|const+diffArray+=+(arr1,+arr2)+=>+arr1.concat(arr2)
++++.filter(val+=>+!(arr1.includes(val)+&&+arr2.includes(val)));

diffArray([1,+2,+3,+7],+[3,+2,+1,+4,+5]);++++//+return+[7,+4,+5]|1495365|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Another way to solve the problem
<pre><code>function diffArray(arr1, arr2) {
 return arr1.concat(arr2).filter(function (val) {
 if (!(arr1.includes(val) &amp;&amp; arr2.includes(val)))
 return val;
 });
}

diffArray([1, 2, 3, 7], [3, 2, 1, 4, 5]); // return [7, 4, 5]
</code></pre>
Also, you can use arrow function syntax:
<pre><code>const diffArray = (arr1, arr2) =&gt; arr1.concat(arr2)
 .filter(val =&gt; !(arr1.includes(val) &amp;&amp; arr2.includes(val)));

diffArray([1, 2, 3, 7], [3, 2, 1, 4, 5]); // return [7, 4, 5]
</code></pre>

blocks|key|1495380|text|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)));
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1495381|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>const difference = function (baseArray, arrayToCampare, callback = (a, b) =&gt; a!== b) {
 if (!(arrayToCampare instanceof Array)) {
 return baseArray;
 }
 return baseArray.filter(baseEl =&gt;
 arrayToCampare.every(compareEl =&gt; callback(baseEl, compareEl)));
}
</code></pre>

blocks|key|1495445|text|使用JavaScript的过滤功能非常简单的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1495446|​|1495447|var+a1+=+['a',+'b'];
var+a2+=+['a',+'b',+'c',+'d'];

function+diffArray(arr1,+arr2)+{
++var+newArr+=+[];
++var+myArr+=+arr1.concat(arr2);
++
++++newArr+=+myArr.filter(function(item){
++++++return+arr2.indexOf(item)+<+0+%7C%7C+arr1.indexOf(item)+<+0;
++++});
+++alert(newArr);
}

diffArray(a1,+a2);|code-block|syntax|javascript|1495448|1495449|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

Very Simple Solution with the filter function of JavaScript:

<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>var a1 = ['a', 'b'];
var a2 = ['a', 'b', 'c', 'd'];

function diffArray(arr1, arr2) {
 var newArr = [];
 var myArr = arr1.concat(arr2);
 
 newArr = myArr.filter(function(item){
 return arr2.indexOf(item) &lt; 0 || arr1.indexOf(item) &lt; 0;
 });
 alert(newArr);
}

diffArray(a1, a2);</code></pre>
</div>
</div>

blocks|key|1495457|text|function+array_diff(a,+b)+{

++++let+array+=+[];
++++for(let+i+=+0;+i+<a.length;+i%2B%2B)+{
++++++++let+k+=+0;
++++++++for(+let+j+=+0;+j+<+b.length;+j%2B%2B)+{
++++++++++++if(a[i]!==b[j])+{
++++++++++++++++k%2B%2B;
++++++++++++}
++++++++++++if(k===b.length)+{
++++++++++++++++array+=+array.concat(a[i]);
++++++++++++}
++++++++}

++++++++if(b.length+===0)+{
++++++++++++array+=+array.concat(a[i]);
++++++++}
++++}
++++return+array;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1495458|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>function array_diff(a, b) {

 let array = [];
 for(let i = 0; i &lt;a.length; i++) {
 let k = 0;
 for( let j = 0; j &lt; 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;
}
</code></pre>

blocks|key|1495484|text|//es6方法|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1495485|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
}|code-block|syntax|javascript|1495486|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

//es6 approach 

<pre><code>function diff(a, b) {
 var u = a.slice(); //dup the array
 b.map(e =&gt; {
 if (u.indexOf(e) &gt; -1) delete u[u.indexOf(e)]
 else u.push(e) //add non existing item to temp array
 })
 return u.filter((x) =&gt; {return (x != null)}) //flatten result
}
</code></pre>

blocks|key|1495531|text|下面是我如何得到两个数组的差异。纯洁无瑕。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1495532|它将返回一个包含添加列表和删除列表对象。|1495533|++function+getDiff(past,+now)+{
++++++++let+ret+=+{+add:+[],+remove:+[]+};
++++++++for+(var+i+=+0;+i+<+now.length;+i%2B%2B)+{
++++++++++if+(past.indexOf(now[i])+<+0)
++++++++++++ret['add'].push(now[i]);
++++++++}
++++++++for+(var+i+=+0;+i+<+past.length;+i%2B%2B)+{
++++++++++if+(now.indexOf(past[i])+<+0)
++++++++++++ret['remove'].push(past[i]);
++++++++}
++++++++return+ret;
++++++}|code-block|syntax|javascript|1495534|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Here is how I get two arrays difference. Pure and clean.

It will return a object that contain [add list] and [remove list].

<pre><code> function getDiff(past, now) {
 let ret = { add: [], remove: [] };
 for (var i = 0; i &lt; now.length; i++) {
 if (past.indexOf(now[i]) &lt; 0)
 ret['add'].push(now[i]);
 }
 for (var i = 0; i &lt; past.length; i++) {
 if (now.indexOf(past[i]) &lt; 0)
 ret['remove'].push(past[i]);
 }
 return ret;
 }
</code></pre>

blocks|key|1495574|text|如果数组不是简单类型，则可以采用上面的答案之一：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1495575|Array.prototype.diff+=+function(a)+{
++++++++return+this.filter(function(i)+{return+a.map(function(e)+{+return+JSON.stringify(e);+}).indexOf(JSON.stringify(i))+<+0;});
++++};|code-block|syntax|javascript|1495576|此方法适用于复杂对象的数组。|1495577|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

If the arrays are not of simple types, then one of the above answers can be adapted:

<pre><code>Array.prototype.diff = function(a) {
 return this.filter(function(i) {return a.map(function(e) { return JSON.stringify(e); }).indexOf(JSON.stringify(i)) &lt; 0;});
 };
</code></pre>

This method works on arrays of complex objects.

blocks|key|1280859|text|您可以使用一个通用对象并计算第一个数组中每个值的频率。对于第二个数组，递减通用对象中的值。然后遍历所有键，并添加所有值大于1的键。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1280860|​|1280861|const+difference+=+(a1,+a2)+=>+{
++var+obj+=+{};
++a1.forEach(v+=>+obj[v]+=+(obj[v]+%7C%7C+0)+%2B+1);
++a2.forEach(v+=>+obj[v]+=+(obj[v]+%7C%7C+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);|code-block|syntax|javascript|1280862|1280863|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

You can use a common object and count the frequency of each value in the first array. For the second array, decrement the value in the common object. Then iterate through all keys and add all the keys whose values is more than 1.

<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const difference = (a1, a2) =&gt; {
 var obj = {};
 a1.forEach(v =&gt; obj[v] = (obj[v] || 0) + 1);
 a2.forEach(v =&gt; obj[v] = (obj[v] || 0) - 1);
 return Object
 .keys(obj)
 .reduce((r,k) =&gt; {
 if(obj[k] &gt; 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);</code></pre>
</div>
</div>

blocks|key|1495659|text|选择的答案只对了一半。您必须以两种方式比较数组才能得到完整的答案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1495660|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'+]|code-block|syntax|javascript|1495661|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The selected answer is only half right. You must compare the arrays both ways to get a complete answer. 

<pre><code>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) // =&gt; [ 'abcd', 'efjk', '9999' ]
</code></pre>

blocks|key|1495698|text|**这将根据“type”参数返回一个唯一值的数组、一个重复数组或一个非重复数组(差异)。**|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1495699|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+%7C%7C+type+===+'uniq'+%7C%7C+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%2B%2B)+{
++++++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'+]|code-block|syntax|javascript|1495700|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

**This returns an array of unique values, or an array of duplicates, or an array of non-duplicates (difference) for any 2 arrays based on the 'type' argument. ** 

<pre><code>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 &lt; 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)) // =&gt; [ 'one', 'two', 'three', 'four' ]
console.log(uniq_n_shit(json1, json2, 'uniq')) // =&gt; [ 'one', 'two', 'three', 'four' ]
console.log(uniq_n_shit(json1, json2, 'duplicate')) // =&gt; [ 'one', 'two' ]
console.log(uniq_n_shit(json1, json2, 'not_duplicate')) // =&gt; [ 'three', 'four' ]
</code></pre>

blocks|key|1280963|text|对我来说，将其作为部分函数处理会更容易一些。很惊讶没有看到函数式编程解决方案，下面是我在ES6中的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1280964|const+arrayDiff+=+(a,+b)+=>+{
++return+diff(b)(a);
}

const+contains+=+(needle)+=>+(array)+=>+{
++for+(let+i=0;+i+<+array.length;+i%2B%2B)+{
++++if+(array[i]+==+needle)+return+true;
++}

++return+false;
}

const+diff+=+(compare)+=>+{
++++return+(array)+=>+array.filter((elem)+=>+!contains(elem)(compare))
}|code-block|syntax|javascript|1280965|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

It feels easier to process this as partial functions to me. Quite surprised not to see a functional programming solution, here is mine in ES6:

<pre><code>const arrayDiff = (a, b) =&gt; {
 return diff(b)(a);
}

const contains = (needle) =&gt; (array) =&gt; {
 for (let i=0; i &lt; array.length; i++) {
 if (array[i] == needle) return true;
 }

 return false;
}

const diff = (compare) =&gt; {
 return (array) =&gt; array.filter((elem) =&gt; !contains(elem)(compare))
}
</code></pre>

blocks|key|1495751|text|var+a1+=+['a',+'b'];
var+a2+=+['a',+'b',+'c',+'d'];
var+diff+=+[];
for+(var+i+in+a2)+{
+++var+found+=+false;
+++for+(var+j+in+a1)+{
++++++if+(a2[i]+===+a1[j])+found+=+true;
+++}
+++if+(found+===+false)+diff.push(a2[i]);
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1495752|就这么简单。也可以与对象一起使用，检查对象的一个属性。喜欢,|unstyled|1495753|if+(a2[i].id+===+a1[j].id)+found+=+true;|1495754|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>var a1 = ['a', 'b'];
var a2 = ['a', 'b', 'c', 'd'];
var diff = [];
for (var i in a2) {
 var found = false;
 for (var j in a1) {
 if (a2[i] === a1[j]) found = true;
 }
 if (found === false) diff.push(a2[i]);
}
</code></pre>

That simple. Could use with objects also, checking one property of object.
Like,

<pre><code>if (a2[i].id === a1[j].id) found = true;
</code></pre>

blocks|key|1495788|text|还有另一个答案，但似乎没有人提到jsperf，他们在比较几种算法和技术支持时：https://jsperf.com/array-difference-javascript似乎使用filter获得了最好的结果。谢谢|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1495789|entityMap|0|LINK|mutability|MUTABLE|url|https://jsperf.com/array-difference-javascript^0|13|1A|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

yet another answer, but seems nobody mentioned jsperf where they compare several algorithms and technology support: <a href="https://jsperf.com/array-difference-javascript" rel="nofollow noreferrer">https://jsperf.com/array-difference-javascript</a> seems using filter gets the best results. thanks

blocks|key|1495828|text|类似于Ian+Grainger的解决方案(但在typescript中)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1495829|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'+]+
//+}|code-block|syntax|javascript|1495830|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Similar to Ian Grainger's solution (but in typescript):

<pre><code>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 &amp;&amp; arrayTwoCopy.length !== 0) {
 if (arrayOneCopy[0] == arrayTwoCopy[0]) {
 share.push(arrayOneCopy[0])
 arrayOneCopy.splice(0, 1)
 arrayTwoCopy.splice(0, 1)
 }
 if (arrayOneCopy[0] &lt; arrayTwoCopy[0]) {
 onlyInArrayOne.push(arrayOneCopy[0])
 arrayOneCopy.splice(0, 1)
 }
 if (arrayOneCopy[0] &gt; 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' ] 
// }
</code></pre>

blocks|key|1495899|text|如果你不关心原始数组，并且编辑它们没有问题，那么这是更快的算法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1495900|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|code-block|syntax|javascript|1495901|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

if you don't care about original arrays and have no problem to edit them then this is quicker algorithm:

<pre><code>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

</code></pre>

blocks|key|1281202|text|基于Thinker's+answer，但允许重复。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1281203|贴图会在映射值出现时递增映射值，如果映射值在其他数组中，则会递减映射值。|1281204|任何剩余的都将包含在差额中。|1281205|​|1281206|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%2B%2B)+{
++++entries[larger[i]]+=+(entries[larger[i]]+%7C%7C+0)+%2B+1;
++}
++for+(var+i+=+0;+i+<+smaller.length;+i%2B%2B)+{
++++if+(entries[smaller[i]])+{
++++++entries[smaller[i]]+-=+1;
++++}+else+{
++++++entries[smaller[i]]+=+(entries[smaller[i]]+%7C%7C+0)+%2B+1;
++++}
++}
++return+Object.keys(entries).sort().reduce((diff,+key)+=>+{
++++if+(entries[key]+>+0)+{
++++++for+(var+i+=+0;+i+<+entries[key];+i%2B%2B)+{
++++++++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+]|code-block|syntax|javascript|1281207|.as-console-wrapper+{+top:+0;+max-height:+100%25+!important;+}|1281208|1281209|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/1187628/1762224^0|2|G|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@$A|10|B|11|1|12]]|C|$]]|$1|D|3|E|5|6|7|13|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|14|8|@]|9|@]|C|$]]|$1|H|3|I|5|6|7|15|8|@]|9|@]|C|$]]|$1|J|3|K|5|L|7|16|8|@]|9|@]|C|$M|N]]|$1|O|3|P|5|L|7|17|8|@]|9|@]|C|$M|N]]|$1|Q|3|I|5|6|7|18|8|@]|9|@]|C|$]]|$1|R|3|-4|5|6|7|19|8|@]|9|@]|C|$]]]|S|$T|$5|U|V|W|C|$X|Y]]]]

Based on <a href="https://stackoverflow.com/a/1187628/1762224">Thinker's answer</a>, but allows duplicates.

The map increments map values as they appear, and decrements them if they are in the other array.

Any leftover will be included in the difference.

<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>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 &lt; larger.length; i++) {
 entries[larger[i]] = (entries[larger[i]] || 0) + 1;
 }
 for (var i = 0; i &lt; 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) =&gt; {
 if (entries[key] &gt; 0) {
 for (var i = 0; i &lt; 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 ]</code></pre>
<pre class="snippet-code-css lang-css prettyprint-override"><code>.as-console-wrapper { top: 0; max-height: 100% !important; }</code></pre>
</div>
</div>

blocks|key|1496023|text|我同意@luis-sieira的解决方案|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1496024|我为初学者创建了bit自解释功能，以便一步步轻松理解：|1496025|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])|code-block|syntax|javascript|1496026|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I agree with the solution of @luis-sieira

I created bit self explanatory function for beginners to understand easily step by step:

<pre><code>function difference(oneArr, twoArr){
 var newArr = [];
 newArr = oneArr.filter((item)=&gt;{
 return !twoArr.includes(item)
 });
 console.log(newArr)
 let arr = twoArr.filter((item)=&gt;{
 return !oneArr.includes(item)
 });
 newArr = newArr.concat(arr);
 console.log(newArr)
}
difference([1, 2, 3, 5], [1, 2, 3, 4, 5])
</code></pre>

blocks|key|1281287|text|使用额外的内存来完成此操作。这样你就可以用更少的时间复杂度来解决它，O(n)而不是o(n*n)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1281288|function+getDiff(arr1,arr2){
let+k+=+{};
let+diff+=+[]
arr1.map(i=>{
++++if+(!k.hasOwnProperty(i))+{
++++++++k[i]+=+1
++++}
}
)
arr2.map(j=>{
++++if+(!k.hasOwnProperty(j))+{
++++++++k[j]+=+1;
++++}+else+{
++++++++k[j]+=+2;
++++}
}
)
for+(var+i+in+k)+{
++++if+(k[i]+===+1)
++++++++diff.push(%2Bi)
}
return+diff
}
getDiff([4,+3,+52,+3,+5,+67,+9,+3],[4,+5,+6,+75,+3,+334,+5,+5,+6])|code-block|syntax|javascript|1281289|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Use extra memory to do this. That way you can solve it with less time complexity, O(n) instead of o(n*n).

<pre><code>function getDiff(arr1,arr2){
let k = {};
let diff = []
arr1.map(i=&gt;{
 if (!k.hasOwnProperty(i)) {
 k[i] = 1
 }
}
)
arr2.map(j=&gt;{
 if (!k.hasOwnProperty(j)) {
 k[j] = 1;
 } else {
 k[j] = 2;
 }
}
)
for (var i in k) {
 if (k[i] === 1)
 diff.push(+i)
}
return diff
}
getDiff([4, 3, 52, 3, 5, 67, 9, 3],[4, 5, 6, 75, 3, 334, 5, 5, 6])
</code></pre>

blocks|key|1496135|text|这是一个稍作修改的版本，它使用一个对象来存储散列，可以处理数组中的数字和字符串。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1496136|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);
}|code-block|syntax|javascript|1496137|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is a slightly modified version that uses an Object to store the hashes can handle numbers as well as strings in arrays.
<pre><code>function arrDiff(a, b) {
 const hash = {};
 a.forEach(n =&gt; { hash[n] = n; });
 b.forEach(n =&gt; {
 if (hash[n]) {
 delete hash[n];
 } else {
 hash[n] = n;
 }
 });
 return Object.values(hash);
}
</code></pre>

blocks|key|1496190|text|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;
+++++++++++++++++++});|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1496191|这将检查数组中哪个更大，然后进行比较。|unstyled|1496192|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>var compare = array1.length &gt; array2.length ? array1 : array2;
var compareWith = array1.length &gt; array2.length ? array2 : array1;
var uniqueValues = compareWith.filter(function(value){
 if(compare.indexOf(vakye) == -1)
 return true;
 });
</code></pre>
This will both check which one is the larger one among the arrays and then will do the comparison.

blocks|key|1496214|text|function+diffArray(newArr,+oldArr)+{
++++var+newSet+=+new+Set(newArr)
++++var+diff+=+[]
++++oldArr.forEach((a)+=>+{
++++++++if(!newSet.delete(a))diff.push(a)
++++})
++++return+diff.concat(Array.from(newSet))+
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1496215|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>function diffArray(newArr, oldArr) {
 var newSet = new Set(newArr)
 var diff = []
 oldArr.forEach((a) =&gt; {
 if(!newSet.delete(a))diff.push(a)
 })
 return diff.concat(Array.from(newSet)) 
}
</code></pre>

blocks|key|1281468|text|++++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)));
++++}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1281469|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code> function arrayDiff(a, b) {
 return a.concat(b).filter(val =&gt; !(b.includes(val)));
 //(or) return a.concat(b).filter(val =&gt; !(a.includes(val) &amp;&amp; b.includes(val)));
 }
</code></pre>

blocks|key|1496285|text|这是另一个可以返回差异的解决方案，就像git+diff一样：(它是用typescript编写的，如果你没有使用typescript版本，只需删除类型即可)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1496286|/**
+*+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%2B%2B)+{
++++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+}),+{})
++}
}|code-block|syntax|javascript|1496287|下面是一个用法示例：|1496288|arrDiff(['a',+'b',+'c'],+['a',+'d',+'c',+'f'])+//{"b":+false,+"d":+true,+"f":+true}|1496289|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Here is another solution which can return the differences, just like git diff: (it has been written in typescript, it you're not using typescript version, simply just remove the types)
<pre><code>/**
 * 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&lt;T&gt;(from: T[], to: T[]): { [x in string]: boolean } {

 var diff: { [x in string]: boolean } = {};
 var newItems: T[] = []
 diff = from.reduce((a, e) =&gt; ({ ...a, [JSON.stringify(e)]: true }), {})

 for (var i = 0; i &lt; 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) =&gt; ({ ...a, [e]: false }), {}),
 ...newItems.reduce((a, e) =&gt; ({ ...a, [JSON.stringify(e)]: true }), {})
 }
}
</code></pre>
Here is a sample of usage:
<pre><code>arrDiff(['a', 'b', 'c'], ['a', 'd', 'c', 'f']) //{&quot;b&quot;: false, &quot;d&quot;: true, &quot;f&quot;: true}
</code></pre>

blocks|key|1496291|text|试试看。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1496292|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]|code-block|syntax|javascript|1496293|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

try it.
<pre><code>var first = [ 1, 2, 3, 4, 5 ];
 var second = [ 4, 5, 6 ];
 
 var difference = first.filter(x =&gt; second.indexOf(x) === -1);
 console.log(difference);


Output: [ 1, 2, 3]
</code></pre>

blocks|key|1281579|text|一个衬垫|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1281580|​|1281581|const+unique+=+(a)+=>+[...new+Set(a)];
const+uniqueBy+=+(x,f)=>Object.values(x.reduce((a,b)=>((a[f(b)]=b),a),{}));
const+intersection+=+(a,+b)+=>+a.filter((v)+=>+b.includes(v));
const+diff+=+(a,+b)+=>+a.filter((v)+=>+!b.includes(v));
const+symDiff+=+(a,+b)+=>+diff(a,+b).concat(diff(b,+a));
const+union+=+(a,+b)+=>+diff(a,+b).concat(b);

const+a+=+unique([1,+2,+3,+4,+5,+5]);
console.log(a);
const+b+=+[4,+5,+6,+7,+8];

console.log(intersection(a,+b),+diff(a,+b),+symDiff(a,+b),+union(a,+b));

console.log(uniqueBy(
++[
{+id:+1,+name:+"abc"+},
{+id:+2,+name:+"xyz"+},
{+id:+1,+name:+"abc"+},
++],
++(v)+=>+v.id
));

const+intersectionBy+=+(a,+b,+f)+=>+a.filter((v)+=>+b.some((u)+=>+f(v,+u)));

console.log(intersectionBy(
+[
++{+id:+1,+name:+"abc"+},
++{+id:+2,+name:+"xyz"+},
+],
+[
++{+id:+1,+name:+"abc"+},
++{+id:+3,+name:+"pqr"+},
+],
+(v,+u)+=>+v.id+===+u.id
));|code-block|syntax|javascript|1281582|1281583|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

<h3>One Liners</h3>
<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const unique = (a) =&gt; [...new Set(a)];
const uniqueBy = (x,f)=&gt;Object.values(x.reduce((a,b)=&gt;((a[f(b)]=b),a),{}));
const intersection = (a, b) =&gt; a.filter((v) =&gt; b.includes(v));
const diff = (a, b) =&gt; a.filter((v) =&gt; !b.includes(v));
const symDiff = (a, b) =&gt; diff(a, b).concat(diff(b, a));
const union = (a, b) =&gt; diff(a, b).concat(b);

const a = unique([1, 2, 3, 4, 5, 5]);
console.log(a);
const b = [4, 5, 6, 7, 8];

console.log(intersection(a, b), diff(a, b), symDiff(a, b), union(a, b));

console.log(uniqueBy(
 [
{ id: 1, name: "abc" },
{ id: 2, name: "xyz" },
{ id: 1, name: "abc" },
 ],
 (v) =&gt; v.id
));

const intersectionBy = (a, b, f) =&gt; a.filter((v) =&gt; b.some((u) =&gt; f(v, u)));

console.log(intersectionBy(
 [
 { id: 1, name: "abc" },
 { id: 2, name: "xyz" },
 ],
 [
 { id: 1, name: "abc" },
 { id: 3, name: "pqr" },
 ],
 (v, u) =&gt; v.id === u.id
));</code></pre>
</div>
</div>

blocks|key|1281605|text|如果您有两个对象列表|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1281606|const+people+=+[{name:+'cesar',+age:+23}]
const+morePeople+=+[{name:+'cesar',+age:+23},+{name:+'kevin',+age:+26},+{name:+'pedro',+age:+25}]

let+result2+=+morePeople.filter(person+=>+people.every(person2+=>+!person2.name.includes(person.name)))|code-block|syntax|javascript|1281607|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If you have two list of objects
<pre><code>const people = [{name: 'cesar', age: 23}]
const morePeople = [{name: 'cesar', age: 23}, {name: 'kevin', age: 26}, {name: 'pedro', age: 25}]

let result2 = morePeople.filter(person =&gt; people.every(person2 =&gt; !person2.name.includes(person.name)))
</code></pre>

Is there a way to return the difference between two arrays in JavaScript?

For example:

<pre class="lang-js prettyprint-override"><code>var a1 = ['a', 'b'];
var a2 = ['a', 'b', 'c', 'd'];

// need ["c", "d"]
</code></pre>

How to get the difference between two arrays in JavaScript?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

有没有办法在JavaScript中返回两个数组之间的差值？例如：var a1 = ['a', 'b'];var a2 = ['a', 'b', 'c', 'd'];// need ["c", "d"]

问如何在JavaScript中得到两个数组之间的差异？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在JavaScript中得到两个数组之间的差异？EN