Wie man den Unterschied zwischen zwei arrays von Objekten in JavaScript

Ich etwas mehr general-purpose-Ansatz, obwohl ähnliche Ideen, um die Ansätze der beiden @Cerbrus und @Kasper Moerch. Ich erstelle eine Funktion, die nimmt ein Prädikat, um zu bestimmen, ob zwei Objekte gleich sind (hier ignorieren wir die $$hashKey Eigenschaft, aber es könnte alles sein) und zurück, eine Funktion, die berechnet die symmetrische Differenz von zwei Listen auf der Grundlage, dass Prädikat:

a = [{ value:"4a55eff3-1e0d-4a81-9105-3ddd7521d642", display:"Jamsheer"}, { value:"644838b3-604d-4899-8b78-09e4799f586f", display:"Muhammed"}, { value:"b6ee537a-375c-45bd-b9d4-4dd84a75041d", display:"Ravi"}, { value:"e97339e1-939d-47ab-974c-1b68c9cfb536", display:"Ajmal"},  { value:"a63a6f77-c637-454e-abf2-dfb9b543af6c", display:"Ryan"}]
b = [{ value:"4a55eff3-1e0d-4a81-9105-3ddd7521d642", display:"Jamsheer", $$hashKey:"008"}, { value:"644838b3-604d-4899-8b78-09e4799f586f", display:"Muhammed", $$hashKey:"009"}, { value:"b6ee537a-375c-45bd-b9d4-4dd84a75041d", display:"Ravi", $$hashKey:"00A"}, { value:"e97339e1-939d-47ab-974c-1b68c9cfb536", display:"Ajmal", $$hashKey:"00B"}]

var makeSymmDiffFunc = (function() {
    var contains = function(pred, a, list) {
        var idx = -1, len = list.length;
        while (++idx < len) {if (pred(a, list[idx])) {return true;}}
        return false;
    };
    var complement = function(pred, a, b) {
        return a.filter(function(elem) {return !contains(pred, elem, b);});
    };
    return function(pred) {
        return function(a, b) {
            return complement(pred, a, b).concat(complement(pred, b, a));
        };
    };
}());

var myDiff = makeSymmDiffFunc(function(x, y) {
    return x.value === y.value && x.display === y.display;
});

var result = myDiff(a, b); //=>  {value="a63a6f77-c637-454e-abf2-dfb9b543af6c", display="Ryan"}

Es hat einen kleinen Vorteil gegenüber Cerebrus Ansatz (wie Kasper Moerch Ansatz), es entweicht; früh, wenn es eine übereinstimmung findet, wird es nicht stören, Sie überprüfen den rest der Liste. Wenn ich ein curry Funktion praktisch, würde ich dies ein wenig anders, aber dies funktioniert gut.

Erklärung

Einen Kommentar gebeten, für eine ausführlichere Erklärung für Anfänger. Hier ist ein Versuch.

Passieren wir die folgende Funktion, um makeSymmDiffFunc:

function(x, y) {
    return x.value === y.value && x.display === y.display;
}

Diese Funktion ist, wie wir entscheiden, dass zwei Objekte gleich sind. Wie alle Funktionen, die Rückkehr true oder false, kann man von einem "Prädikat-Funktion", aber das ist nur Terminologie. Der wichtigste Punkt ist, dass makeSymmDiffFunc konfiguriert ist, mit einer Funktion akzeptiert zwei Objekte und gibt true wenn wir prüfen Sie gleich, false wenn wir nicht.

Mit, dass makeSymmDiffFunc (Lesen Sie "machen symmetrischen Differenz-Funktion") gibt uns eine neue Funktion:

        return function(a, b) {
            return complement(pred, a, b).concat(complement(pred, b, a));
        };

Dies ist die Funktion, die wir tatsächlich nutzen. Wir übergeben es zwei Listen und findet die Elemente in der ersten nicht in die zweite, dann die zweite nicht in den ersten und kombinieren Sie diese beiden Listen.

Suchen über es wieder, obwohl, ich könnte auf jeden Fall genommen haben, ein Stichwort aus Ihrem code und vereinfacht die main-Funktion ganz ein bisschen durch die Nutzung some:

var makeSymmDiffFunc = (function() {
    var complement = function(pred, a, b) {
        return a.filter(function(x) {
            return !b.some(function(y) {return pred(x, y);});
        });
    };
    return function(pred) {
        return function(a, b) {
            return complement(pred, a, b).concat(complement(pred, b, a));
        };
    };
}());

complement verwendet das Prädikat und liefert die Elemente der ersten Liste nicht in der zweiten. Dies ist einfacher als meinen ersten Durchgang mit einem separaten contains Funktion.

Schließlich die main-Funktion ist verpackt in eine sofort invoked function expression (IIFE) zum halten der internen complement Funktion aus dem globalen Bereich.

Update, ein paar Jahre später

Nun, dass ES2015 hat sich ziemlich gut überall, ich würde vorschlagen, die gleiche Technik, mit viel weniger boilerplate:

const diffBy = (pred) => (a, b) => a.filter(x => !b.some(y => pred(x, y)))
const makeSymmDiffFunc = (pred) => (a, b) => diffBy(pred)(a, b).concat(diffBy(pred)(b, a))

const myDiff = makeSymmDiffFunc((x, y) => x.value === y.value && x.display === y.display)

const result = myDiff(a, b)
//=>  {value="a63a6f77-c637-454e-abf2-dfb9b543af6c", display="Ryan"}

InformationsquelleAutor Scott Sauyet

import differenceBy from 'lodash/differenceBy'

const myDifferences = differenceBy(Result1, Result2, 'value')

Wird das Ergebnis die Differenz zwischen zwei arrays von Objekten, mit der Taste value zu vergleichen. Beachten Sie zwei Dinge mit dem gleichen Wert wird nicht zurückgegeben, wie die anderen Tasten werden ignoriert.

Dies ist ein Teil von lodash.

InformationsquelleAutor Noah

Meisten Antworten hier sind ziemlich Komplex, aber ist nicht die Logik dahinter ganz einfach?

1. überprüfen Sie das array länger ist und geben Sie als ersten parameter (wenn die Länge ist gleich, die Parameter-Reihenfolge egal)
2. Durchlaufen array1.
3. Für die aktuelle iteration element von array1 prüfen, ob es vorhanden ist in array2
4. Wenn es NICHT vorhanden ist, als
5. Schieben Sie es auf 'Differenz' array

const getArraysDifference = (longerArray, array2) => {
  const difference = [];

  longerArray.forEach(el1 => {      /*1*/
    el1IsPresentInArr2 = array2.some(el2 => el2.value === el1.value); /*2*/

    if (!el1IsPresentInArr2) { /*3*/
      difference.push(el1);    /*4*/
    }
  });

  return difference;
}

O(n^2) Komplexität.

InformationsquelleAutor azrahel

Verwenden nur native JS, so etwas wie dies funktionieren wird:

JS:

a = [{ value:"4a55eff3-1e0d-4a81-9105-3ddd7521d642", display:"Jamsheer"}, { value:"644838b3-604d-4899-8b78-09e4799f586f", display:"Muhammed"}, { value:"b6ee537a-375c-45bd-b9d4-4dd84a75041d", display:"Ravi"}, { value:"e97339e1-939d-47ab-974c-1b68c9cfb536", display:"Ajmal"},  { value:"a63a6f77-c637-454e-abf2-dfb9b543af6c", display:"Ryan"}]
b = [{ value:"4a55eff3-1e0d-4a81-9105-3ddd7521d642", display:"Jamsheer", $$hashKey:"008"}, { value:"644838b3-604d-4899-8b78-09e4799f586f", display:"Muhammed", $$hashKey:"009"}, { value:"b6ee537a-375c-45bd-b9d4-4dd84a75041d", display:"Ravi", $$hashKey:"00A"}, { value:"e97339e1-939d-47ab-974c-1b68c9cfb536", display:"Ajmal", $$hashKey:"00B"}]

function comparer(otherArray){
  return function(current){
    return otherArray.filter(function(other){
      return other.value == current.value && other.display == current.display
    }).length == 0;
  }
}

var onlyInA = a.filter(comparer(b));
var onlyInB = b.filter(comparer(a));

result = onlyInA.concat(onlyInB);

console.log(result);

Ich etwas mehr general-purpose-Ansatz, obwohl ähnliche Ideen, um die Ansätze der beiden @Cerbrus und @Kasper Moerch. Ich erstelle eine Funktion, die nimmt ein Prädikat, um zu bestimmen, ob zwei Objekte gleich sind (hier ignorieren wir die $$hashKey Eigenschaft, aber es könnte alles sein) und zurück, eine Funktion, die berechnet die symmetrische Differenz von zwei Listen auf der Grundlage, dass Prädikat:

a = [{ value:"4a55eff3-1e0d-4a81-9105-3ddd7521d642", display:"Jamsheer"}, { value:"644838b3-604d-4899-8b78-09e4799f586f", display:"Muhammed"}, { value:"b6ee537a-375c-45bd-b9d4-4dd84a75041d", display:"Ravi"}, { value:"e97339e1-939d-47ab-974c-1b68c9cfb536", display:"Ajmal"},  { value:"a63a6f77-c637-454e-abf2-dfb9b543af6c", display:"Ryan"}]
b = [{ value:"4a55eff3-1e0d-4a81-9105-3ddd7521d642", display:"Jamsheer", $$hashKey:"008"}, { value:"644838b3-604d-4899-8b78-09e4799f586f", display:"Muhammed", $$hashKey:"009"}, { value:"b6ee537a-375c-45bd-b9d4-4dd84a75041d", display:"Ravi", $$hashKey:"00A"}, { value:"e97339e1-939d-47ab-974c-1b68c9cfb536", display:"Ajmal", $$hashKey:"00B"}]

var makeSymmDiffFunc = (function() {
    var contains = function(pred, a, list) {
        var idx = -1, len = list.length;
        while (++idx < len) {if (pred(a, list[idx])) {return true;}}
        return false;
    };
    var complement = function(pred, a, b) {
        return a.filter(function(elem) {return !contains(pred, elem, b);});
    };
    return function(pred) {
        return function(a, b) {
            return complement(pred, a, b).concat(complement(pred, b, a));
        };
    };
}());

var myDiff = makeSymmDiffFunc(function(x, y) {
    return x.value === y.value && x.display === y.display;
});

var result = myDiff(a, b); //=>  {value="a63a6f77-c637-454e-abf2-dfb9b543af6c", display="Ryan"}

Es hat einen kleinen Vorteil gegenüber Cerebrus Ansatz (wie Kasper Moerch Ansatz), es entweicht; früh, wenn es eine übereinstimmung findet, wird es nicht stören, Sie überprüfen den rest der Liste. Wenn ich ein curry Funktion praktisch, würde ich dies ein wenig anders, aber dies funktioniert gut.

Erklärung

Einen Kommentar gebeten, für eine ausführlichere Erklärung für Anfänger. Hier ist ein Versuch.

Passieren wir die folgende Funktion, um makeSymmDiffFunc:

function(x, y) {
    return x.value === y.value && x.display === y.display;
}

Diese Funktion ist, wie wir entscheiden, dass zwei Objekte gleich sind. Wie alle Funktionen, die Rückkehr true oder false, kann man von einem "Prädikat-Funktion", aber das ist nur Terminologie. Der wichtigste Punkt ist, dass makeSymmDiffFunc konfiguriert ist, mit einer Funktion akzeptiert zwei Objekte und gibt true wenn wir prüfen Sie gleich, false wenn wir nicht.

Mit, dass makeSymmDiffFunc (Lesen Sie "machen symmetrischen Differenz-Funktion") gibt uns eine neue Funktion:

        return function(a, b) {
            return complement(pred, a, b).concat(complement(pred, b, a));
        };

Dies ist die Funktion, die wir tatsächlich nutzen. Wir übergeben es zwei Listen und findet die Elemente in der ersten nicht in die zweite, dann die zweite nicht in den ersten und kombinieren Sie diese beiden Listen.

Suchen über es wieder, obwohl, ich könnte auf jeden Fall genommen haben, ein Stichwort aus Ihrem code und vereinfacht die main-Funktion ganz ein bisschen durch die Nutzung some:

var makeSymmDiffFunc = (function() {
    var complement = function(pred, a, b) {
        return a.filter(function(x) {
            return !b.some(function(y) {return pred(x, y);});
        });
    };
    return function(pred) {
        return function(a, b) {
            return complement(pred, a, b).concat(complement(pred, b, a));
        };
    };
}());

complement verwendet das Prädikat und liefert die Elemente der ersten Liste nicht in der zweiten. Dies ist einfacher als meinen ersten Durchgang mit einem separaten contains Funktion.

Schließlich die main-Funktion ist verpackt in eine sofort invoked function expression (IIFE) zum halten der internen complement Funktion aus dem globalen Bereich.

Update, ein paar Jahre später

Nun, dass ES2015 hat sich ziemlich gut überall, ich würde vorschlagen, die gleiche Technik, mit viel weniger boilerplate:

const diffBy = (pred) => (a, b) => a.filter(x => !b.some(y => pred(x, y)))
const makeSymmDiffFunc = (pred) => (a, b) => diffBy(pred)(a, b).concat(diffBy(pred)(b, a))

const myDiff = makeSymmDiffFunc((x, y) => x.value === y.value && x.display === y.display)

const result = myDiff(a, b)
//=>  {value="a63a6f77-c637-454e-abf2-dfb9b543af6c", display="Ryan"}

import differenceBy from 'lodash/differenceBy'

const myDifferences = differenceBy(Result1, Result2, 'value')

Wird das Ergebnis die Differenz zwischen zwei arrays von Objekten, mit der Taste value zu vergleichen. Beachten Sie zwei Dinge mit dem gleichen Wert wird nicht zurückgegeben, wie die anderen Tasten werden ignoriert.

Dies ist ein Teil von lodash.

Für diejenigen, die one-liner-Lösungen in ES6, so etwas wie dieses:

JS:

const arrayOne = [ 
  { value: "4a55eff3-1e0d-4a81-9105-3ddd7521d642", display: "Jamsheer" },
  { value: "644838b3-604d-4899-8b78-09e4799f586f", display: "Muhammed" },
  { value: "b6ee537a-375c-45bd-b9d4-4dd84a75041d", display: "Ravi" },
  { value: "e97339e1-939d-47ab-974c-1b68c9cfb536", display: "Ajmal" },
  { value: "a63a6f77-c637-454e-abf2-dfb9b543af6c", display: "Ryan" },
];
          
const arrayTwo = [
  { value: "4a55eff3-1e0d-4a81-9105-3ddd7521d642", display: "Jamsheer"},
  { value: "644838b3-604d-4899-8b78-09e4799f586f", display: "Muhammed"},
  { value: "b6ee537a-375c-45bd-b9d4-4dd84a75041d", display: "Ravi"},
  { value: "e97339e1-939d-47ab-974c-1b68c9cfb536", display: "Ajmal"},
];

const results = arrayOne.filter(({ value: id1 }) => !arrayTwo.some(({ value: id2 }) => id2 === id1));

console.log(results);

Habe ich eine generalisierte diff vergleichen 2 Objekte von jeder Art und kann auf eine änderung handler
gist.github.com/bortunac "diff.js"
eine ex von mit :

old_obj={a:1,b:2,c:[1,2]}
now_obj={a:2 , c:[1,3,5],d:55}

also eine Eigenschaft geändert wird, wird b gelöscht wird, c geändert, d Hinzugefügt

var handler=function(type,pointer){
console.log(type,pointer,this.old.point(pointer)," | ",this.now.point(pointer)); 

}

nun verwenden wie

df=new diff();
df.analize(now_obj,old_obj);
df.react(handler);

die Konsole zeigt

mdf ["a"]  1 | 2 
mdf ["c", "1"]  2 | 3 
add ["c", "2"]  undefined | 5 
add ["d"]  undefined | 55 
del ["b"]  2 | undefined 

Wenn Sie bereit sind für die Verwendung von externen Bibliotheken, die Sie verwenden können _.Unterschied in underscore.js um dies zu erreichen. _.Unterschied gibt die Werte aus dem array, die nicht in den anderen arrays.

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

==>[2,3,5]