Added difference() function to compute difference between two objects

Author: luca-vogels

package.json

@@ -1,6 +1,6 @@
 {
   "name": "lup-utils",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "NodeJS library providing utility functions.",
   "main": "./lib/index",
   "types": "./lib/index.d.ts",

src/__tests__/object.test.ts

@@ -1,4 +1,4 @@
-import { deepEqual } from '../object';
+import { deepEqual, difference } from '../object';
 
 test('deepEqual()', async () => {
   // Primitive values (true)
@@ -56,6 +56,7 @@ test('deepEqual()', async () => {
   expect(deepEqual({ a: [1, 2], b: 3 }, { a: [1, 2], b: 3 }, true)).toBe(true);
 
   // Object strict order (false)
+  expect(deepEqual({ a: 1 }, { b: 2 }, true)).toBe(false);
   expect(deepEqual({ a: 1, b: 2 }, { b: 2, a: 1 }, true)).toBe(false);
   expect(deepEqual({ a: 1, b: { c: 3 } }, { b: { c: 3 }, a: 1 }, true)).toBe(false);
   expect(deepEqual({ a: [1, 2], b: 3 }, { b: 3, a: [1, 2] }, true)).toBe(false);
@@ -68,7 +69,54 @@ test('deepEqual()', async () => {
   expect(deepEqual({ a: [1, 2], b: 3 }, { b: 3, a: [1, 2] }, false)).toBe(true);
 
   // Object unordered (false)
+  expect(deepEqual({ b: 2 }, { b: 3 }, false)).toBe(false);
   expect(deepEqual({ a: 1, b: 2 }, { a: 1, b: 3 }, false)).toBe(false);
   expect(deepEqual({ a: 1, b: 2 }, { a: 1 })).toBe(false);
   expect(deepEqual({ a: 1 }, { a: 1, b: 2 })).toBe(false);
 });
+
+test('difference()', async () => {
+  expect(difference({}, {}, { recursive: false, ignoreOrder: false })).toEqual({});
+  expect(difference({ a: 1 }, { a: 1 }, { recursive: false, ignoreOrder: false })).toEqual({});
+  expect(difference({ a: 1 }, { a: 2 }, { recursive: false, ignoreOrder: false })).toEqual({ a: 2 });
+  expect(difference({ a: 1, b: 2 }, { a: 1 }, { recursive: false, ignoreOrder: false })).toEqual({ b: undefined });
+  expect(difference({ a: 1 }, { a: 1, b: 2 }, { recursive: false, ignoreOrder: false })).toEqual({ b: 2 });
+  expect(
+    difference(
+      { a: { b: 2, c: { d: 3, e: 4 } } },
+      { a: { b: 2, c: { d: 3, e: 4 } } },
+      { recursive: false, ignoreOrder: false },
+    ),
+  ).toEqual({});
+  expect(
+    difference(
+      { a: { b: 2, c: { d: 3, e: 4 } } },
+      { a: { b: 3, c: { d: 3, e: 4 } } },
+      { recursive: false, ignoreOrder: false },
+    ),
+  ).toEqual({ a: { b: 3, c: { d: 3, e: 4 } } });
+  expect(
+    difference(
+      { a: { b: 2, c: { d: 3, e: 4 } } },
+      { a: { b: 2, c: { d: 3, e: 5 } } },
+      { recursive: false, ignoreOrder: false },
+    ),
+  ).toEqual({ a: { b: 2, c: { d: 3, e: 5 } } });
+  expect(difference({ a: [1, 2, 3] }, { a: [1, 2, 3] }, { recursive: false, ignoreOrder: false })).toEqual({});
+  expect(difference({ a: [1, 2, 3] }, { a: [3, 2, 1] }, { recursive: false, ignoreOrder: false })).toEqual({
+    a: [3, 2, 1],
+  });
+  expect(difference({ a: [1, 2, 3] }, { a: [4, 5, 6] }, { recursive: false, ignoreOrder: false })).toEqual({
+    a: [4, 5, 6],
+  });
+
+  expect(difference({ a: [1, 2, 3] }, { a: [3, 2, 1] }, { recursive: false, ignoreOrder: true })).toEqual({});
+
+  expect(
+    difference(
+      { a: { b: 2, c: { d: 3, e: 4 } } },
+      { a: { b: 2, c: { d: 3, e: 5 } } },
+      { recursive: true, ignoreOrder: false },
+    ),
+  ).toEqual({ a: { c: { e: 5 } } });
+});

src/object.ts

@@ -36,3 +36,58 @@ export function deepEqual(a: any, b: any, strictOrder: boolean = false): boolean
   }
   return false;
 }
+
+/**
+ * Compares two objects and returns a new object containing all keys that have different values.
+ * If two arrays are different, the entire new array is included in the result.
+ * @param oldObj Old object to compare to.
+ * @param newObj New object to compare from and from which to take values.
+ * @param options Additional options for comparison.
+ * @returns An object containing all keys that have different values (if value is missing in newObj, value is set to undefined).
+ */
+export function difference<O, N>(
+  oldObj: O,
+  newObj: N,
+  options?: {
+    /** Whether to ignore the order of items in arrays. */
+    ignoreOrder?: boolean;
+
+    /** Whether to perform a deep comparison of nested objects (does not apply to arrays). */
+    recursive?: boolean;
+  },
+): Partial<O & N> {
+  if (typeof oldObj !== 'object' || oldObj === null || typeof newObj !== 'object' || newObj === null) {
+    return deepEqual(oldObj, newObj, !options?.ignoreOrder) ? (oldObj as any) : (newObj as any);
+  }
+  const diff: Partial<O & N> = {};
+  const oldKeys = new Set<string>(Object.keys(oldObj));
+  const newKeys = new Set<string>(Object.keys(newObj));
+
+  // iterate old object
+  for (const key of oldKeys) {
+    newKeys.delete(key);
+    const oldValue: any = (oldObj as any)[key]!;
+    const newValue: any = (newObj as any)[key];
+
+    // recursive difference
+    if (options?.recursive && typeof oldValue === 'object' && oldValue !== null) {
+      if (typeof newValue !== 'object' || newValue === null) {
+        (diff as any)[key] = newValue;
+        continue;
+      }
+      (diff as any)[key] = difference(oldValue, newValue, options);
+      continue;
+    }
+
+    // flat difference
+    if (!deepEqual(oldValue, newValue, !options?.ignoreOrder)) (diff as any)[key] = newValue;
+  }
+
+  // iterate new object
+  for (const key of newKeys) {
+    const newValue: any = (newObj as any)[key]!;
+    (diff as any)[key] = newValue;
+  }
+
+  return diff;
+}