deep-match2 v1.0.1

Check if two values deeply match

deepMatch(object, matcher)

All properties and nested objects mentioned in the matcher are required to be present in object.

Library is version of deep-match. Difference:

• in deep-match during comparison of arrays order of items do not matters
• in deep-match2 you can set options = { arrayOrderMatters: true } to force that during comparison order of items in object and matcher should be the same.

// two objects that look exactly the same
deepMatch({ a: 1, b: 2 } }, { a: 1, b: 2 }); // true

// additional properties on the left-hand side are ignored
deepMatch({ a: 1, b: 2 } }, { a: 1 }); // true

// everything on the right-hand side is required
deepMatch({ a: 1 } }, { a: 1, b: 2 }); // false

// same for arrays
deepMatch([1, 2, 3], [1, 2]); // true
deepMatch([1, 2, 3], [3, 4]); // false

Regular expressions and functions in the matcher are run against the corresponding values in the object:

deepMatch('aaa', /a+/); // true
deepMatch('bbb', /a+/); // false
deepMatch(['aaa', 'bbb'], [/a+/]); // true
deepMatch(['aaa', 'bbb'], [/a+/, /b+/]); // true
deepMatch(['aaa', 'ccc'], [/a+/, /b+/]); // false
deepMatch([1, 2, 3], [v => v === 1]); // true

When matching arrays order of items do not matters by default. To change it you can use additional parameter:

let opts = { arrayOrderMatters: true };
deepMatch([1, 2], [1, 2], opts); // true
deepMatch([1, 2], [2, 1], opts); // false
deepMatch([1, 2], [   2], opts); // false

// disable checks for undefined items
// [,2] is the same as [undefined, 2]
deepMatch([1, 2], [ , 2], opts); // true

// arrayOrderMatters applies also to nested arrays:
source  = { a1: [ {i1: []}, {i2: [1, 2,         [31, 32, 33], 4, 5]} ]};
matcher = { a1: [ {i1: []}, {i2: [1, undefined, [32, 33    ],  , 5]} ]};
deepMatch(source, matcher, opts); // false
deepMatch(source, matcher);       // false

// Note that in case of arrayOrderMatters=false undefined is not skipped
source  = { a1: [ {i1: []}, {i2: [1, 2,         [31, 32,        33], 4, 5]} ]};
matcher = { a1: [ {i1: []}, {i2: [1, undefined, [31, undefined, 33],  , 5]} ]};
deepMatch(source, matcher, opts); // true
deepMatch(source, matcher);       // false

Rules

Values are compared according to the following rules:

• Identical values always match.
• Values of different types never match.
• Values that are no objects only match if they are identical (see above).
• Null values (which are also objects) only match if both are null.
• Arrays match if all items in the matcher match (note different behavior for option arrayOrderMatters).
• When arrayOrderMatters=true value of undefined matchers are skipped.
• When arrayOrderMatters=false (default behavior) value of undefined matchers are NOT skipped.
• Objects match if all properties in the matcher match.

License

MIT