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;

我想要一个类似的函数，它接受一个旧数组和一个新数组，并给我一个添加项的数组和一个删除项的数组，我希望它是有效的(所以没有.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}; 
}

贡献一个jQuery解决方案，我目前正在使用:

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

转换为字符串对象类型:

[1, 1].toString() === [1, 1].toString(); // true

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

这是受到了思想者接受的答案的启发，但是思想者的答案似乎假设数组是集合。如果数组是["1"，"2"]和["1"，"1"，"2"，"2"]，它就不成立了

这些数组之间的差值是["1"，"2"]。下面的解决方案是O(n*n)，所以不理想，但如果您有大数组，它也比思想者的解决方案具有内存优势。

如果你首先处理的是集合，思想者的解决方案肯定更好。如果你有一个可以访问过滤器的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;
    }
}