Exclude some properties in comparison using isEqual() of lodash

Question

I am using _.isEqual that compares 2 array of objects (ex:10 properties each object), and it is working fine.

Now there are 2 properties (creation and deletion) that i need not to be a part of comparison.

Example:

var obj1 = {name: "James", age: 17, creation: "13-02-2016", deletion: "13-04-2016"}
var obj2 = {name: "Maria", age: 17, creation: "13-02-2016", deletion: "13-04-2016"}

// lodash method...
_.isEqual(firstArray, secondArray)

Answer 1

You can use omit() to remove specific properties in an object.

var result = _.isEqual(
  _.omit(obj1, ['creation', 'deletion']),
  _.omit(obj2, ['creation', 'deletion'])
);

var obj1 = {
  name: "James",
  age: 17,
  creation: "13-02-2016",
  deletion: "13-04-2016"
};

var obj2 = {
  name: "Maria",
  age: 17,
  creation: "13-02-2016",
  deletion: "13-04-2016"
};

var result = _.isEqual(
  _.omit(obj1, ['creation', 'deletion']),
  _.omit(obj2, ['creation', 'deletion'])
);

console.log(result);

<script src="https://cdn.jsdelivr.net/lodash/4.13.1/lodash.min.js"></script>

Answer 2

@ryeballar's answer is not great for large objects because you are creating a deep copy of each object every time you do the comparison.

It's better to use isEqualWith. For example, to ignore differences in the "creation" and "deletion" properties:

var result = _.isEqualWith(obj1, obj2, (value1, value2, key) => {
    return key === "creation" || key === "deletion" ? true : undefined;
});

EDIT (important caveat pointed out in the comments): if objects have different numbers of keys, then isEqualWith considers them to be different, regadless of what your customizer does. Therefore do not use this approach if you want to ignore an optional property. Instead, consider using _.isMatch(), _.isMatchWith(), or @ryeballar's _.omit() approach.

Note that if you're writing for ES5 and earlier, you'll have to replace the arrow syntax (() => {) with function syntax (function() {)

Answer 3

_.omit creates deep copy of the object. If you need to exclude only root props it is better to create shallow copy using, for example, destructuring assignment:

const x = { a: 4, b: [1, 2], c: 'foo' }
const y = { a: 4, b: [1, 2], c: 'bar' }

const { c: xC, ...xWithoutC } = x
const { c: yC, ...yWithoutC } = y

_.isEqual(xWithoutC, yWithoutC) // true
xWithoutC.b === x.b             // true, would be false if you use _.omit

Best way is not to create copies at all (TypeScript):

function deepEqual(
  x?: object | null,
  y?: object | null,
  ignoreRootProps?: Set<string>
) {
  if (x == null || y == null) return x === y

  const keys = Object.keys(x)
  if (!_.isEqual(keys, Object.keys(y)) return false

  for (let key of keys) {
    if (ignoreRootProps && ignoreRootProps.has(key)) continue
    if (!_.isEqual(x[key], y[key])) return false
  }
  return true
}

Answer 4

You could map your array into a "cleaned" array, then compare those.

// Create a function, to do some cleaning of the objects.
var clean = function(obj) {
    return {name: obj.name, age: obj.age};
};

// Create two new arrays, which are mapped, 'cleaned' copies of the original arrays.
var array1 = firstArray.map(clean);
var array2 = secondArray.map(clean);

// Compare the new arrays.
_.isEqual(array1, array2);

This has the downside that the clean function will need to be updated if the objects are expecting any new properties. It is possible to edit it so that it removes the two unwanted properties instead.

Answer 5

I see two options.

1) Make a second copy of each object that doesn't contain the creation or date.

2) Loop through all the properties and, assuming you know for certain that they both have the same properties, try something like this.

var x ={}
var y ={}
for (var property in x) {
if(property!="creation" || property!="deletion"){
if (x.hasOwnProperty(property)) {
        compare(x[property], y[property])
    }
}
}

Where compare() is some simple string or object comparison. If you are certain of the properties on one or both the objects, you can simplify this code a bit further, but this should work in most cases.

Answer 6

My final solution required a full comparison ignoring an optional property so the above solutions did not work.

I used a shallow clone to remove the keys I wanted to ignore from each object before comparing with isEqual:

const equalIgnoring = (newItems, originalItems) => newItems.length === originalItems.length
    && newItems.every((newItem, index) => {
        const rest1 = { ...newItem };
        delete rest1.creation;
        delete rest1.deletion;
        const rest2 = { ...originalItems[index] };
        delete rest2.creation;
        delete rest2.deletion;
        return isEqual(rest1, rest2);
    });

If you want to check a subset for each item in the array this works:

const equalIgnoringExtraKeys = (fullObjs, partialObjs) => 
    fullObjs.length === partialObjs.length
    && fullObjs.every((fullObj, index) => isMatch(fullObj, partialObjs[index]));

If you also want to ignore a specific property and check subset:

const subsetIgnoringKeys = (fullObjs, partialObjs) => 
    fullObjs.length === partialObjs.length
    && fullObjs.every((fullObj, index) => isMatchWith(
        fullObj,
        partialObjs[index],
        (objValue, srcValue, key, object, source) => {
            if (["creation", "deletion"].includes(key)) {
                return true;
            }
            return undefined;
        }
    ));