Jak uzyskać różnicę między dwiema tablicami w JavaScript?

Czy istnieje sposób na zwrócenie różnicy między dwiema tablicami w JavaScript?

Na przykład:

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

// need ["c", "d"]

Zakładam, że porównujesz normalną tablicę. Jeśli nie, musisz zmienić pętlę for na pętlę 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"));

Lepszym rozwiązaniem, jeśli nie zależy ci na kompatybilności wstecznej, jest użycie filtra. Ale nadal to rozwiązanie działa.

Istnieje lepszy sposób korzystania z ES7:

Skrzyżowanie

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

Bo [1,2,3] [2,3]się podda[2,3] . Z drugiej strony, bo [1,2,3] [2,3,5]zwróci to samo.

Różnica

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

Dla [1,2,3] [2,3] się podda[1] . Z drugiej strony, bo [1,2,3] [2,3,5]zwróci to samo.

Aby uzyskać różnicę symetryczną , możesz:

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

W ten sposób otrzymasz tablicę zawierającą wszystkie elementy arr1, których nie ma w arr2 i odwrotnie

Jak zauważył @Joshaven Potter w swojej odpowiedzi, możesz dodać to do Array.prototype, aby można go było użyć w następujący sposób:

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

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

Uwaga indeks i filtr nie są dostępne np. Przed ie9.

Jest to zdecydowanie najłatwiejszy sposób na uzyskanie dokładnie tego, czego szukasz, za pomocą jQuery:

var diff = $(old_array).not(new_array).get();

diffteraz zawiera to, co było w old_arraytym, czego nie manew_array

Metoda różnicy w Underscore (lub jej zastąpienie, Lo-Dash ) również może to zrobić:

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

Podobnie jak w przypadku każdej funkcji podkreślenia, możesz również używać jej w stylu bardziej obiektowym:

_([1, 2, 3, 4, 5]).difference([5, 2, 10]);

Zwykły JavaScript

Istnieją dwie możliwe interpretacje „różnicy”. Pozwolę ci wybrać, który chcesz. Powiedz, że masz:

var a1 = ['a', 'b'     ];
var a2 = [     'b', 'c'];

1. Jeśli chcesz uzyskać ['a'], użyj tej funkcji:

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

2. Jeśli chcesz dostać ['a', 'c'](wszystkie elementy zawarte w jednym z nich a1 lub w a2obu - tak zwana różnica symetryczna ), użyj tej funkcji:

   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

Jeśli używasz lodash, możesz użyć _.difference(a1, a2)(przypadek 1 powyżej) lub _.xor(a1, a2)(przypadek 2).

Jeśli używasz Underscore.js, możesz użyć _.difference(a1, a2) funkcji dla przypadku 1.

Zestaw ES6, do bardzo dużych tablic

Powyższy kod działa we wszystkich przeglądarkach. Jednak w przypadku dużych tablic składających się z ponad 10 000 elementów staje się dość wolny, ponieważ ma złożoność O (n²). W wielu nowoczesnych przeglądarkach możemy skorzystać z Setobiektu ES6, aby przyspieszyć działanie. Lodash automatycznie używa, Setgdy jest dostępny. Jeśli nie korzystasz z lodash, skorzystaj z następującej implementacji, zainspirowanej postem na blogu Axela Rauschmayera :

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

Notatki

Zachowanie wszystkich przykładów może być zaskakujące lub nieoczywiste, jeśli zależy Ci na -0, +0, NaN lub rzadkich tablicach. (W przypadku większości zastosowań nie ma to znaczenia).

Aby uzyskać różnicę symetryczną , musisz porównać tablice na dwa sposoby (lub na wszystkie sposoby w przypadku wielu tablic)

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

Przykład:

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

Różnica między tablicami obiektów

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

Przykład:

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

Czystsze podejście w ES6 to następujące rozwiązanie.

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

Różnica

a2.filter(d => !a1.includes(d)) // gives ["c", "d"]

Skrzyżowanie

a2.filter(d => a1.includes(d)) // gives ["a", "b"]

Unia dysjunkcyjna (różnica symetryczna)

[ ...a2.filter(d => !a1.includes(d)),
  ...a1.filter(d => !a2.includes(d)) ]

W takim przypadku możesz użyć zestawu . Jest zoptymalizowany do tego rodzaju operacji (połączenie, przecięcie, różnica).

Upewnij się, że dotyczy twojej sprawy, gdy nie zezwala na powielanie.

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}

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

Scal obie tablice, unikalne wartości pojawią się tylko raz, więc indexOf () będzie taki sam jak lastIndexOf ().

aby odjąć jedną tablicę od drugiej, po prostu użyj poniższego fragmentu:

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

Zwróci [„1,” 2 ”,„ 6 ”], które są elementami pierwszej tablicy, które nie istnieją w drugiej.

Dlatego, zgodnie z twoim przykładem problemu, dokładnym rozwiązaniem jest następujący kod:

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

Wraz z pojawieniem się ES6 z zestawami i operatorem splat (w chwili, gdy działa tylko w Firefoksie, sprawdź tabelę zgodności ), możesz napisać jedną linijkę:

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

co spowoduje [ "c", "d" ].

Funkcjonalne podejście z ES2015

Obliczanie differencemiędzy dwoma tablicami jest jedną z Setoperacji. Termin ten już wskazuje, że Setnależy użyć rodzimego typu, aby zwiększyć szybkość wyszukiwania. Tak czy inaczej, podczas obliczania różnicy między dwoma zestawami istnieją trzy kombinacje:

[+left difference] [-intersection] [-right difference]
[-left difference] [-intersection] [+right difference]
[+left difference] [-intersection] [+right difference]

Oto funkcjonalne rozwiązanie, które odzwierciedla te permutacje.

Po lewej difference:

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

Po prawej difference:

differencerjest banalny. To tylko differencelz odwróconymi argumentami. Możesz napisać funkcję dla wygody:const differencer = flip(differencel) . To wszystko!

Symetryczny difference:

Teraz, gdy mamy lewą i prawą, implementacja symetrycznej również differencestaje się trywialna:

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

Myślę, że ten przykład jest dobrym punktem wyjścia do uzyskania wrażenia, co oznacza programowanie funkcjonalne:

Programowanie z elementami składowymi, które można łączyć ze sobą na wiele różnych sposobów.

Zastosowanie rozwiązania indexOf()będzie odpowiednie dla małych tablic, ale wraz ze wzrostem długości zbliża się wydajność algorytmu O(n^2). Oto rozwiązanie, które będzie działać lepiej dla bardzo dużych tablic, wykorzystując obiekty jako tablice asocjacyjne do przechowywania wpisów tablicy jako kluczy; eliminuje również automatycznie zduplikowane wpisy, ale działa tylko z wartościami ciągów (lub wartościami, które można bezpiecznie przechowywać jako ciągi znaków):

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

Powyższa odpowiedź Joshaven Potter jest świetna. Ale zwraca elementy z tablicy B, których nie ma w tablicy C, ale nie na odwrót. Na przykład, jeśli var a=[1,2,3,4,5,6].diff( [3,4,5,7]);następnie wyświetli: ==> [1,2,6], ale nie [1,2,6,7] , co jest faktyczną różnicą między nimi. Nadal możesz użyć powyższego kodu Pottera, ale po prostu powtórz porównanie raz wstecz:

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

To powinno wygenerować: [ 1, 2, 6, 7 ]

Kolejny sposób rozwiązania problemu

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]

Możesz także użyć składni funkcji strzałek:

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]

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]

Bardzo proste rozwiązanie z funkcją filtrowania JavaScript:

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 || arr1.indexOf(item) < 0;
    });
   alert(newArr);
}

diffArray(a1, a2);

Co powiesz na to:

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

Więc w ten sposób możesz zrobić, array1.diff(array2)aby uzyskać ich różnicę (choć straszna złożoność czasu dla algorytmu - O (wydaje mi się, że macierz1.length x macierz2.length)

Za pomocą http://phrogz.net/JS/ArraySetMath.js możesz:

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

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

to działa dla mnie

• Rozwiązanie Pure JavaScript (bez bibliotek)
• Kompatybilny ze starszymi przeglądarkami (nie używa filter)
• O (n ^ 2)
• Opcjonalny fnparametr wywołania zwrotnego, który pozwala określić sposób porównywania elementów tablicy

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(', ')
);

Działa to: po prostu scal dwie tablice, poszukaj duplikatów i wepchnij to, co nie jest duplikowane, do nowej tablicy, co jest różnicą.

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

// podejście 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
}

Złożoność symetryczna i liniowa . Wymaga 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));
}

jeszcze jedna odpowiedź, ale wydaje się, że nikt nie wspominał o jsperf, w którym porównują kilka algorytmów i obsługę technologii: https://jsperf.com/array-difference-javascript wydaje się, że użycie filtra daje najlepsze wyniki. dzięki

Po prostu myślę ... ze względu na wyzwanie ;-) czy to zadziała ... (dla podstawowych tablic ciągów, liczb itp.) Brak tablic zagnieżdżonych

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

Zauważ, że sortowanie prawdopodobnie nie będzie takie, jak wspomniano powyżej ... ale w razie potrzeby wywołaj funkcję .sort () na tablicy, aby ją posortować.

Chciałem podobnej funkcji, która przyjęła starą tablicę i nową tablicę i dała mi tablicę dodanych elementów i tablicę usuniętych elementów, i chciałem, aby była wydajna (więc nie. Zawiera!).

Możesz zagrać z moim proponowanym rozwiązaniem tutaj: http://jsbin.com/osewu3/12 .

Czy ktoś może zobaczyć jakiekolwiek problemy / ulepszenia tego algorytmu? Dzięki!

Lista kodów:

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

Szukałem prostej odpowiedzi, która nie wymagałaby używania różnych bibliotek, i wymyśliłem swoją własną, o której nie sądzę, żeby tu była wspomniana. Nie wiem, jak wydajna jest, ani nic, ale działa;

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

W przypadku mojego kodu potrzebuję również duplikatów, ale myślę, że nie zawsze jest to preferowane.

Myślę, że główną wadą jest to, że potencjalnie porównuje wiele opcji, które zostały już odrzucone.

poprawka littlebit dla najlepszej odpowiedzi

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

weźmie to pod uwagę obecny typ elementu. b / c, gdy tworzymy [a1 [i]], konwertuje wartość na ciąg znaków z jej pierwotnej wartości, więc straciliśmy wartość rzeczywistą.