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

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

那么简单。也可以用于对象，检查对象的一个属性。 就像,

if (a2[i].id === a1[j].id) found = true;

所选的答案只对了一半。您必须比较数组的两种方式才能得到完整的答案。

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' ]

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

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

快速的解决方案。尽管似乎其他人已经发布了相同方法的不同变体。我不确定这是否适合大型数组，但它适用于不大于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);
    }
  }
}

在这种情况下，您可以使用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}