Naturally Pacifist Marsupials

    deep-match2
    TypeScript icon, indicating that this package has built-in type declarations

    1.0.1 • Public • Published

    Build Status

    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

    Install

    npm i deep-match2

    DownloadsWeekly Downloads

    2

    Version

    1.0.1

    License

    MIT

    Unpacked Size

    5.73 kB

    Total Files

    4

    Last publish

    Collaborators

    • fider