使用ES7有一个更好的方法:

十字路口

 let intersection = arr1.filter(x => arr2.includes(x));

对于[1,2,3][2,3]，它将生成[2,3]。另一方面，for[1,2,3][2,3,5]将返回相同的结果。

区别

let difference = arr1.filter(x => !arr2.includes(x));

对于[1,2,3][2,3]，它将生成[1]。另一方面，for[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中。原型，所以它可以这样使用:

Array.prototype.diff = function(arr2) { return this.filter(x => !arr2.includes(x)); }
[1, 2, 3].diff([2, 3])

const a1 = ['a', 'b', 'c', 'd'];
const a2 = ['a', 'b'];

const diffArr = a1.filter(o => !a2.includes(o));

console.log(diffArr);

输出:

[ 'a', 'b' ]

只是想…为了一个挑战;-)这个工作…(对于字符串，数字等的基本数组)没有嵌套数组

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()对其进行排序。

我一直在寻找一个不涉及使用不同库的简单答案，我想出了我自己的答案，我想这里没有提到过。 我不知道它的效率如何，但它确实有效;

    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;
    }

对于我的代码，我也需要删除副本，但我想这并不总是可取的。

我想主要的缺点是它可能会比较许多已经被拒绝的选择。

求两个没有重复项的数组的差值:

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]

注意:上述解决方案要求始终将较大的数组作为第二个参数发送。要找到绝对差值，首先需要找到两者的较大数组，然后对它们进行处理。

求两个不存在重复项的数组的绝对差值:

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

我已经尝试了以上所有这些，但没有一个工作时，你需要匹配不接受副本。

例如:

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;
    });
};