Hoe u het verschil kunt krijgen tussen twee arrays in JavaScript?

Array.prototype.diff = function(a) {
    return this.filter(function(i) {return a.indexOf(i) < 0;});
};
//////////////
// Examples //
//////////////
const dif1 = [1,2,3,4,5,6].diff( [3,4,5] );  
console.log(dif1); // => [1, 2, 6]
const dif2 = ["test1", "test2","test3","test4","test5","test6"].diff(["test1","test2","test3","test4"]);  
console.log(dif2); // => ["test5", "test6"]

Antwoord 4, autoriteit 90%

Dit is verreweg de gemakkelijkste manier om precies het resultaat te krijgen waarnaar u op zoek bent, met jQuery:

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

diffbevat nu wat in old_arraystond en niet in new_array

Antwoord 5, autoriteit 63%

De verschilmethode in Underscore(of de drop-in vervanging, Lo-Dash) kan dit ook:

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

Zoals bij elke Underscore-functie, kunt u deze ook in een meer objectgeoriënteerde stijl gebruiken:

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

Antwoord 6, autoriteit 32%

Gewoon JavaScript

Er zijn twee mogelijke interpretaties voor “verschil”. Ik laat je kiezen welke je wilt. Stel dat je het volgende hebt:

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

1. Als je ['a']wilt krijgen, gebruik dan deze functie:

   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. Als u ['a', 'c'](alle elementen in ofwela1of a2, maar niet beide — het zogenaamde symmetrische verschil), gebruik deze functie:

   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

Als je lodash gebruikt, kun je _.difference(a1, a2)gebruiken (geval 1 hierboven) of _.xor(a1, a2)(geval 2).

Als u Underscore.js gebruikt, kunt u de _.difference(a1, a2)functie voor geval 1.

ES6 Set, voor zeer grote arrays

De bovenstaande code werkt in alle browsers. Voor grote arrays van meer dan ongeveer 10.000 items wordt het echter vrij traag, omdat het O(n²) complexiteit heeft. In veel moderne browsers kunnen we profiteren van de ES6 Setobject in om dingen te versnellen. Lodash gebruikt automatisch Setwanneer het beschikbaar is. Als je geen lodash gebruikt, gebruik dan de volgende implementatie, geïnspireerd door Axel Rauschmayer’s blog bericht:

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

Opmerkingen

Het gedrag voor alle voorbeelden kan verrassend of niet duidelijk zijn als u om -0, +0, nan of dunne arrays. (Voor de meeste toepassingen doet dit niet uit.)

7, Autoriteit 23%

Een schonere aanpak in ES6 is de volgende oplossing.

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

verschil

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

kruising

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

Disjunctive Union (symmetrisch verschil)

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

Antwoord 8, autoriteit 12%

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

Voeg beide arrays samen, unieke waarden verschijnen slechts één keer, dus indexOf() zal hetzelfde zijn als lastIndexOf().

Antwoord 9, autoriteit 10%

Met de komst van ES6 met sets en splat-operator (werkt momenteel alleen in Firefox, controleer compatibiliteitstabel), kunt u de volgende oneliner schrijven:

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

wat resulteert in [ "c", "d" ].

Antwoord 10, autoriteit 7%

om de ene array van de andere af te trekken, gebruik je het onderstaande fragment:

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

Het retourneert [‘1,’2′,’6’] die items van de eerste array zijn die niet bestaan in de tweede.

Daarom, volgens uw probleemvoorbeeld, is de volgende code de exacte oplossing:

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

Antwoord 11, autoriteit 6%

Functionele aanpak met ES2015

Het differencetussen twee arrays berekenen is een van de Set-bewerkingen. De term geeft al aan dat het native type Setmoet worden gebruikt om de opzoeksnelheid te verhogen. Hoe dan ook, er zijn drie permutaties als je het verschil tussen twee sets berekent:

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

Hier is een functionele oplossing die deze permutaties weerspiegelt.

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

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]

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]

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

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

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

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]

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

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

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

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

_.difference([1, 2, 3, 4, 5], [5, 2, 10]);
=> [1, 3, 4]
_.intersection([1, 2, 3], [101, 2, 1, 10], [2, 1]);
=> [1, 2]

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

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
}

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

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(+i)
}
return diff
}
getDiff([4, 3, 52, 3, 5, 67, 9, 3],[4, 5, 6, 75, 3, 334, 5, 5, 6])

function difference(arr1, arr2){
  let setA = new Set(arr1);
  let differenceSet = new Set(arr2.filter(ele => !setA.has(ele)));
  return [...differenceSet ];
}

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