JavaScript

NPM包 @golden-tiger/difference 介绍：

对比出两个JavaScript对象的差异，并能够通过属性值路径覆盖生成自定义的对比结果，以此可以实现对部分属性值的差异忽略，或者组合多个属性值生成一个差异项。

安装：

npm i @golden-tiger/difference

使用：

difference(before, after, option)

What is difference

difference function will find out what is different between two javascript object. (P.s. number, string and boolean are also javascript object)

How to use difference(before, after, option)

Use difference function to get differences between the first parameter before and the second after. And difference function's third parameter control difference's process.

• before: the before value for difference
• after: the after value for difference
• option.routes: initial routes
• option.arrayInOrder: weather array needs keep order when contrast
• option.arraySort sort: function when array keeps order
• option.covers: Covers' array to custom specific contrast handler for specific routes. Handle function's return should be an array consisted of difference item({ routes, before, after }) or a falsy value. Handle function's return will be pushed into the diff results array when it is not a falsy value.
• return: Array of difference item. Difference item consists of routes (routes in object), before (before value) and after (after value).

Examples

1. number

difference(1, 1);
// []
difference(1, 2);
// [ { routes: [], before: 1, after: 2 } ]

2. string

difference('foo', 'foo');
// []
difference('foo', 'bar');
// [ { routes: [], before: 'foo', after: 'bar' } ]

3. boolean

difference(true, true);
// []
difference(false, false);
// []
difference(true, false);
// [ { routes: [], before: true, after: false } ]

4. array

option.arrayInOrder(boolean) decides whether an array is in order. Sort function is (a, b) => a < b ? -1 : 1 by default, which can be set with option.arraySort(Function). difference function will take array's sorted result as input.

difference([1, 'foo'], [1, 'foo']);
// []
difference([1, 'foo'], [2, 'bar']);
// [
//   { routes: [ '1' ], before: 'foo', after: 'bar' },
//   { routes: [ '0' ], before: 1, after: 2 }
// ]

difference([1, 2], [2, 1]);
// []
difference([1, 2], [2, 1], {
  arrayInOrder: true,
});
// [
//   { routes: [ '1' ], before: 2, after: 1 },
//   { routes: [ '0' ], before: 1, after: 2 }
// ]

difference(['foo', 'bar'], ['bar', 'foo']);
// []
difference(['foo', 'bar'], ['bar', 'foo'], {
  arrayInOrder: true,
});
// [
//   { routes: [ '1' ], before: 'bar', after: 'foo' },
//   { routes: [ '0' ], before: 'foo', after: 'bar' }
// ]

5. object

difference({ a: 'foo' }, { a: 'foo' });
// []
difference({ a: 'foo' }, { a: 'bar' });
// [ { routes: [ 'a' ], before: 'foo', after: 'bar' } ]
difference({ a: 'foo' }, { b: 'foo' });
// [
//   { routes: [ 'b' ], before: undefined, after: 'foo' },
//   { routes: [ 'a' ], before: 'foo', after: undefined }
// ]

6. option.covers

handler function's falsy return will be ignore in difference result. Using handler function you can custom the difference result, such as ignoring some specific route value or combining several route values to one difference item.

difference({ a: 'foo' }, { a: 'bar' }, {
  covers: [
    {
      routes: ['a'],
      handler: (before, after, routes) => {
        console.log(before);
        // foo
        console.log(after);
        // bar
        console.log(routes);
        // [ 'a' ]
        return false;
      },
    }
  ],
});
// []
difference({ a: 'foo' }, { a: 'bar' }, {
  covers: [
    {
      routes: ['a'],
      handler: (before, after, routes) => {
        return [
          { routes, before, after },
        ];
      },
    }
  ],
});
// [ { routes: [ 'a' ], before: 'foo', after: 'bar' } ]