如何获取JavaScript中两个arrays对象的区别

Question

I have two result sets like this:

// Result 1
[
    { value: "0", display: "Jamsheer" },
    { value: "1", display: "Muhammed" },
    { value: "2", display: "Ravi" },
    { value: "3", display: "Ajmal" },
    { value: "4", display: "Ryan" }
]

// Result 2
[
    { value: "0", display: "Jamsheer" },
    { value: "1", display: "Muhammed" },
    { value: "2", display: "Ravi" },
    { value: "3", display: "Ajmal" },
]

The final result I need is the difference between these arrays – the final result should be like this:

[{ value: "4", display: "Ryan" }]

Is it possible to do something like this in JavaScript?

Answer 1

Using only native JS, something like this will work:

 const 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"}]; const 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"}]; // A comparer used to determine if two entries are equal. const isSameUser = (a, b) => a.value == b.value && a.display == b.display; // Get items that only occur in the left array, // using the compareFunction to determine equality. const onlyInLeft = (left, right, compareFunction) => left.filter(leftValue => !right.some(rightValue => compareFunction(leftValue, rightValue))); const onlyInA = onlyInLeft(a, b, isSameUser); const onlyInB = onlyInLeft(b, a, isSameUser); const result = [...onlyInA, ...onlyInB]; console.log(result);

Answer 2

For those who like one-liner solutions in ES6, something like this:

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

Answer 3

You could use Array.prototype.filter() in combination with Array.prototype.some() .

Here is an example (assuming your arrays are stored in the variables result1 and result2 ):

//Find values that are in result1 but not in result2
var uniqueResultOne = result1.filter(function(obj) {
    return !result2.some(function(obj2) {
        return obj.value == obj2.value;
    });
});

//Find values that are in result2 but not in result1
var uniqueResultTwo = result2.filter(function(obj) {
    return !result1.some(function(obj2) {
        return obj.value == obj2.value;
    });
});

//Combine the two arrays of unique entries
var result = uniqueResultOne.concat(uniqueResultTwo);

Answer 4

import differenceBy from 'lodash/differenceBy'

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

This will return the difference between two arrays of objects, using the key value to compare them. Note two things with the same value will not be returned, as the other keys are ignored.

This is a part of lodash .

Answer 5

I take a slightly more general-purpose approach, although similar in ideas to the approaches of both @Cerbrus and @Kasper Moerch . I create a function that accepts a predicate to determine if two objects are equal (here we ignore the $$hashKey property, but it could be anything) and return a function which calculates the symmetric difference of two lists based on that predicate:

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

It has one minor advantage over Cerebrus's approach (as does Kasper Moerch's approach) in that it escapes early; if it finds a match, it doesn't bother checking the rest of the list. If I had a curry function handy, I would do this a little differently, but this works fine.

Explanation

A comment asked for a more detailed explanation for beginners. Here's an attempt.

We pass the following function to makeSymmDiffFunc :

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

This function is how we decide that two objects are equal. Like all functions that return true or false , it can be called a "predicate function", but that's just terminology. The main point is that makeSymmDiffFunc is configured with a function that accepts two objects and returns true if we consider them equal, false if we don't.

Using that, makeSymmDiffFunc (read "make symmetric difference function") returns us a new function:

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

This is the function we will actually use. We pass it two lists and it finds the elements in the first not in the second, then those in the second not in the first and combine these two lists.

Looking over it again, though, I could definitely have taken a cue from your code and simplified the main function quite a bit by using 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 uses the predicate and returns the elements of its first list not in its second. This is simpler than my first pass with a separate contains function.

Finally, the main function is wrapped in an immediately invoked function expression ( IIFE ) to keep the internal complement function out of the global scope.

---

Update, a few years later

Now that ES2015 has become pretty well ubiquitous, I would suggest the same technique, with a lot less 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"}

Answer 6

I think the @Cerbrus solution is spot on. I have implemented the same solution but extracted the repeated code into it's own function (DRY).

 function filterByDifference(array1, array2, compareField) {
  var onlyInA = differenceInFirstArray(array1, array2, compareField);
  var onlyInb = differenceInFirstArray(array2, array1, compareField);
  return onlyInA.concat(onlyInb);
}

function differenceInFirstArray(array1, array2, compareField) {
  return array1.filter(function (current) {
    return array2.filter(function (current_b) {
        return current_b[compareField] === current[compareField];
      }).length == 0;
  });
}

Answer 7

You can create an object with keys as the unique value corresponding for each object in array and then filter each array based on existence of the key in other's object. It reduces the complexity of the operation.

ES6

 let 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"}]; let 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"}]; let valuesA = a.reduce((a,{value}) => Object.assign(a, {[value]:value}), {}); let valuesB = b.reduce((a,{value}) => Object.assign(a, {[value]:value}), {}); let result = [...a.filter(({value}) => !valuesB[value]), ...b.filter(({value}) => !valuesA[value])]; console.log(result);

ES5

 var 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"}]; var 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 valuesA = a.reduce(function(a,c){a[c.value] = c.value; return a; }, {}); var valuesB = b.reduce(function(a,c){a[c.value] = c.value; return a; }, {}); var result = a.filter(function(c){ return !valuesB[c.value]}).concat(b.filter(function(c){ return !valuesA[c.value]})); console.log(result);

Answer 8

In addition, say two object array with different key value

// Array Object 1
const arrayObjOne = [
    { userId: "1", display: "Jamsheer" },
    { userId: "2", display: "Muhammed" },
    { userId: "3", display: "Ravi" },
    { userId: "4", display: "Ajmal" },
    { userId: "5", display: "Ryan" }
]

// Array Object 2
const arrayObjTwo =[
    { empId: "1", display: "Jamsheer", designation:"Jr. Officer" },
    { empId: "2", display: "Muhammed", designation:"Jr. Officer" },
    { empId: "3", display: "Ravi", designation:"Sr. Officer" },
    { empId: "4", display: "Ajmal", designation:"Ast. Manager" },
]

You can use filter in es5 or native js to substract two array object.

//Find data that are in arrayObjOne but not in arrayObjTwo
var uniqueResultArrayObjOne = arrayObjOne.filter(function(objOne) {
    return !arrayObjTwo.some(function(objTwo) {
        return objOne.userId == objTwo.empId;
    });
});

In ES6 you can use Arrow function with Object destructuring of ES6 .

const ResultArrayObjOne = arrayObjOne.filter(({ userId: userId }) => !arrayObjTwo.some(({ empId: empId }) => empId === userId));

console.log(ResultArrayObjOne);

Answer 9

I found this solution using filter and some.

 resultFilter = (firstArray, secondArray) => { return firstArray.filter(firstArrayItem => !secondArray.some( secondArrayItem => firstArrayItem._user === secondArrayItem._user ) ); };

Answer 10

you can do diff a on b and diff b on a, then merge both results

 let a = [ { value: "0", display: "Jamsheer" }, { value: "1", display: "Muhammed" }, { value: "2", display: "Ravi" }, { value: "3", display: "Ajmal" }, { value: "4", display: "Ryan" } ] let b = [ { value: "0", display: "Jamsheer" }, { value: "1", display: "Muhammed" }, { value: "2", display: "Ravi" }, { value: "3", display: "Ajmal" } ] // b diff a let resultA = b.filter(elm => !a.map(elm => JSON.stringify(elm)).includes(JSON.stringify(elm))); // a diff b let resultB = a.filter(elm => !b.map(elm => JSON.stringify(elm)).includes(JSON.stringify(elm))); // show merge console.log([...resultA, ...resultB]);

Answer 11

 let obj1 =[ { id: 1, submenu_name: 'login' }, { id: 2, submenu_name: 'Profile',}, { id: 3, submenu_name: 'password', }, { id: 4, submenu_name: 'reset',} ] ; let obj2 =[ { id: 2}, { id: 3 }, ] ; // Need Similar obj const result1 = obj1.filter(function(o1){ return obj2.some(function(o2){ return o1.id == o2.id; // id is unnique both array object }); }); console.log(result1); // Need differnt obj const result2 = obj1.filter(function(o1){ return !obj2.some(function(o2){ // for diffrent we use NOT (!) befor obj2 here return o1.id == o2.id; // id is unnique both array object }); }); console.log(result2);

Answer 12

Most of the observed code does not examine the whole object and only compares the value of a particular method. This solution is the same, except that you can specify that method yourself.

Here is an example:

const arr1 = [
   {
      id: 1,
      name: "Tom",
      scores: {
         math: 80,
         science: 100
      }
   },
   {
      id: 2,
      name: "John",
      scores: {
         math: 50,
         science: 70
      }
   }
];
const arr2 = [
   {
      id: 1,
      name: "Tom",
      scores: {
         math: 80,
         science: 70
      }
   }
];

function getDifference(array1, array2, attr) {
  return array1.filter(object1 => {
    return !array2.some(object2 => {
      return eval("object1." + attr + " == object2." + attr);
    });
  });
}

// 👇️ [{id: 2, name: 'John'...
console.log(getDifference(arr1, arr2, "id"));

// 👇️ [{id: 2, name: 'John'...
console.log(getDifference(arr1, arr2, "scores.math"));

// 👇️ [{id: 1, name: 'Tom'...
console.log(getDifference(arr1, arr2, "scores.science"));

Answer 13

Most of answers here are rather complex, but isn't logic behind this quite simple?

1. check which array is longer and provide it as first parameter (if length is equal, parameters order doesnt matter)
2. Iterate over array1.
3. For current iteration element of array1 check if it is present in array2
4. If it is NOT present, than
5. Push it to 'difference' 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) complexity.

Answer 14

I prefer map object when it comes to big arrays.

 // create tow arrays array1 = Array.from({length: 400},() => ({value:Math.floor(Math.random() * 4000)})) array2 = Array.from({length: 400},() => ({value:Math.floor(Math.random() * 4000)})) // calc diff with some function console.time('diff with some'); results = array2.filter(({ value: id1 }) => array1.some(({ value: id2 }) => id2 === id1)); console.log('diff results ',results.length) console.timeEnd('diff with some'); // calc diff with map object console.time('diff with map'); array1Map = {}; for(const item1 of array1){ array1Map[item1.value] = true; } results = array2.filter(({ value: id2 }) => array1Map[id2]); console.log('map results ',results.length) console.timeEnd('diff with map');

Answer 15

Having:

const array = [{id:3, name:'xx'} , {id:7, name:'yy'}, {id:9, name:'zz'}];
const array2 =[3,4,5];//These are a group of ids

I made a function that removes the objects from array that matches de ids within array2, like this:

export const aFilter = (array, array2) => {
   
   array2.forEach(element => {
      array = array.filter(item=> item.id !== element);
   });
   return array;
}

After calling the function we should have the array with no object wit id = 3

const rta = aFilter(array, array2);
//rta should be = [{id:7, name:'yy'}, {id:9, name:'zz'}];

It worked for me, and was pretty easy

Answer 16

I've made a generalized diff that compare 2 objects of any kind and can run a modification handler gist.github.com/bortunac "diff.js" an ex of using :

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

so property a is modified, b is deleted, c modified, d is added

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

}

now use like

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

the console will show

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

Answer 17

Most generic and simple way:

findObject(listOfObjects, objectToSearch) {
    let found = false, matchingKeys = 0;
    for(let object of listOfObjects) {
        found = false;
        matchingKeys = 0;
        for(let key of Object.keys(object)) {
            if(object[key]==objectToSearch[key]) matchingKeys++;
        }
        if(matchingKeys==Object.keys(object).length) {
            found = true;
            break;
        }
    }
    return found;
}

get_removed_list_of_objects(old_array, new_array) {
    // console.log('old:',old_array);
    // console.log('new:',new_array);
    let foundList = [];
    for(let object of old_array) {
        if(!this.findObject(new_array, object)) foundList.push(object);
    }
    return foundList;
}

get_added_list_of_objects(old_array, new_array) {
    let foundList = [];
    for(let object of new_array) {
        if(!this.findObject(old_array, object)) foundList.push(object);
    }
    return foundList;
}

Answer 18

JavaScript has Maps, that provide O(1) insertion and lookup time. Therefore this can be solved in O(n) (and not O(n²) as all the other answers do). For that, it is necessary to generate a unique primitive (string / number) key for each object. One could JSON.stringify , but that's quite error prone as the order of elements could influence equality:

 JSON.stringify({ a: 1, b: 2 }) !== JSON.stringify({ b: 2, a: 1 })

Therefore, I'd take a delimiter that does not appear in any of the values and compose a string manually:

const toHash = value => value.value + "@" + value.display;

Then a Map gets created. When an element exists already in the Map, it gets removed, otherwise it gets added. Therefore only the elements that are included odd times (meaning only once) remain. This will only work if the elements are unique in each array:

const entries = new Map();

for(const el of [...firstArray, ...secondArray]) {
  const key = toHash(el);
  if(entries.has(key)) {
    entries.delete(key);
  } else {
    entries.set(key, el);
  }
}

const result = [...entries.values()];

 const firstArray = [ { value: "0", display: "Jamsheer" }, { value: "1", display: "Muhammed" }, { value: "2", display: "Ravi" }, { value: "3", display: "Ajmal" }, { value: "4", display: "Ryan" } ] const secondArray = [ { value: "0", display: "Jamsheer" }, { value: "1", display: "Muhammed" }, { value: "2", display: "Ravi" }, { value: "3", display: "Ajmal" }, ]; const toHash = value => value.value + "@" + value.display; const entries = new Map(); for(const el of [...firstArray, ...secondArray]) { const key = toHash(el); if(entries.has(key)) { entries.delete(key); } else { entries.set(key, el); } } const result = [...entries.values()]; console.log(result);

Answer 19

I came across this question while searching for a way to pick out the first item in one array that does not match any of the values in another array and managed to sort it out eventually with array.find() and array.filter() like this

var carList= ['mercedes', 'lamborghini', 'bmw', 'honda', 'chrysler'];
var declinedOptions = ['mercedes', 'lamborghini'];

const nextOption = carList.find(car=>{
    const duplicate = declinedOptions.filter(declined=> {
      return declined === car
    })
    console.log('duplicate:',duplicate) //should list out each declined option
    if(duplicate.length === 0){//if theres no duplicate, thats the nextOption
      return car
    }
})

console.log('nextOption:', nextOption);
//expected outputs
//duplicate: mercedes
//duplicate: lamborghini
//duplicate: []
//nextOption: bmw

if you need to keep fetching an updated list before cross-checking for the next best option this should work well enough :)

Answer 20

最简单的方法可能是使用过滤器和一些一起使用请参考下面的链接DifferenceInTwoArrayOfObjectInSimpleWay

Answer 21

@atheane response: fork :

 const newList = [ { value: "4a55eff3-1e0d-4a81-9105-3ddd7521d642", display: "Jamsheer" }, { value: "644838b3-604d-4899-8b78-09e4799f586f", display: "Muhammed" }, { value: "b6ee537a-375c-45bd-b9d4-4dd84a75041d", display: "Ravi2" }, { value: "a63a6f77-c637-454e-abf2-dfb9b543af6c", display: "Ryan" }, ]; const oldList = [ { 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 resultsAdd = newList.filter(({ value: id1 }) =>.oldList:some(({ value; id2 }) => id2 === id1)). const resultsRemove = oldList:filter(({ value. id1 }) =>:newList;some(({ value. id2 }) => id2 === id1)): const resultsUpdate = newList,filter(({ value. id1. ..:rest1 }) => oldList,some(({ value. id2. ...rest2 }) => id2 === id1 && JSON;stringify(rest1).== JSON,stringify(rest2))); console.log("added", resultsAdd); console.log("removed", resultsRemove); console.log("updated", resultsUpdate);

Answer 22

If you are willing to use external libraries, You can use _.difference in underscore.js to achieve this. _.difference returns the values from array that are not present in the other arrays.

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

==>[2,3,5]