assert,util: improve deep object comparison performance

This improves the performance for almost all objects when comparing
them deeply.

Author: BridgeAR

benchmark/assert/deepequal-prims-and-objs-big-loop.js

@@ -14,7 +14,6 @@ const primValues = {
   'number': 1_000,
   'boolean': true,
   'object': { property: 'abcdef' },
-  'object_other_property': { property: 'abcdef' },
   'array': [1, 2, 3],
   'set_object': new Set([[1]]),
   'set_simple': new Set([1, 2, 3]),

benchmark/assert/deepequal-set.js

@@ -6,7 +6,7 @@ const { deepEqual, deepStrictEqual, notDeepEqual, notDeepStrictEqual } =
 
 const bench = common.createBenchmark(main, {
   n: [1e3],
-  len: [5e2],
+  len: [2, 5e2],
   strict: [0, 1],
   method: [
     'deepEqual_primitiveOnly',

benchmark/assert/partial-deep-equal.js

@@ -62,7 +62,7 @@ function createSets(length, extraProps, depth = 0) {
       number: i,
     },
     ['array', 'with', 'values'],
-    !depth ? new Set([1, 2, { nested: i }]) : new Set(),
+    !depth ? new Set([1, { nested: i }]) : new Set(),
     !depth ? createSets(2, extraProps, depth + 1) : null,
   ]));
 }

lib/internal/util/comparisons.js

@@ -9,6 +9,7 @@ const {
   DatePrototypeGetTime,
   Error,
   NumberPrototypeValueOf,
+  ObjectGetOwnPropertyDescriptor,
   ObjectGetOwnPropertySymbols: getOwnSymbols,
   ObjectGetPrototypeOf,
   ObjectIs,
@@ -192,7 +193,10 @@ function innerDeepEqual(val1, val2, mode, memos) {
         typeof val1 !== 'object' ||
         val1 === null ||
         val2 === null ||
-        (mode === kStrict && ObjectGetPrototypeOf(val1) !== ObjectGetPrototypeOf(val2))) {
+        (mode === kStrict &&
+          (val1.constructor !== val2.constructor ||
+            (val1.constructor === undefined &&
+              ObjectGetPrototypeOf(val1) !== ObjectGetPrototypeOf(val2))))) {
       return false;
     }
   } else {
@@ -316,6 +320,10 @@ function innerDeepEqual(val1, val2, mode, memos) {
              isNativeError(val2) ||
              val2 instanceof Error) {
     return false;
+  } else if (isURL(val1)) {
+    if (!isURL(val2) || val1.href !== val2.href) {
+      return false;
+    }
   } else if (isKeyObject(val1)) {
     if (!isKeyObject(val2) || !val1.equals(val2)) {
       return false;
@@ -332,10 +340,6 @@ function innerDeepEqual(val1, val2, mode, memos) {
     }
   } else if (isWeakMap(val1) || isWeakSet(val1)) {
     return false;
-  } else if (isURL(val1)) {
-    if (!isURL(val2) || val1.href !== val2.href) {
-      return false;
-    }
   }
 
   return keyCheck(val1, val2, mode, memos, kNoIterator);
@@ -345,6 +349,21 @@ function getEnumerables(val, keys) {
   return ArrayPrototypeFilter(keys, (key) => hasEnumerable(val, key));
 }
 
+function partialSymbolEquiv(val1, val2, keys2) {
+  const symbolKeys = getOwnSymbols(val2);
+  if (symbolKeys.length !== 0) {
+    for (const key of symbolKeys) {
+      if (hasEnumerable(val2, key)) {
+        if (!hasEnumerable(val1, key)) {
+          return false;
+        }
+        ArrayPrototypePush(keys2, key);
+      }
+    }
+  }
+  return true;
+}
+
 function keyCheck(val1, val2, mode, memos, iterationType, keys2) {
   // For all remaining Object pairs, including Array, objects and Maps,
   // equivalence is determined by having:
@@ -358,31 +377,15 @@ function keyCheck(val1, val2, mode, memos, iterationType, keys2) {
   if (keys2 === undefined) {
     keys2 = ObjectKeys(val2);
   }
-
-  // Cheap key test
-  if (keys2.length > 0) {
-    for (const key of keys2) {
-      if (!hasEnumerable(val1, key)) {
-        return false;
-      }
-    }
-  }
+  let keys1;
 
   if (!isArrayLikeObject) {
     // The pair must have the same number of owned properties.
     if (mode === kPartial) {
-      const symbolKeys = getOwnSymbols(val2);
-      if (symbolKeys.length !== 0) {
-        for (const key of symbolKeys) {
-          if (hasEnumerable(val2, key)) {
-            if (!hasEnumerable(val1, key)) {
-              return false;
-            }
-            ArrayPrototypePush(keys2, key);
-          }
-        }
+      if (!partialSymbolEquiv(val1, val2, keys2)) {
+        return false;
       }
-    } else if (keys2.length !== ObjectKeys(val1).length) {
+    } else if (keys2.length !== (keys1 = ObjectKeys(val1)).length) {
       return false;
     } else if (mode === kStrict) {
       const symbolKeysA = getOwnSymbols(val1);
@@ -431,7 +434,7 @@ function keyCheck(val1, val2, mode, memos, iterationType, keys2) {
       d: undefined,
       deep: false,
     };
-    return objEquiv(val1, val2, mode, keys2, memos, iterationType);
+    return objEquiv(val1, val2, mode, keys1, keys2, memos, iterationType);
   }
 
   if (memos.set === undefined) {
@@ -445,7 +448,7 @@ function keyCheck(val1, val2, mode, memos, iterationType, keys2) {
       memos.c = val1;
       memos.d = val2;
       memos.deep = true;
-      const result = objEquiv(val1, val2, mode, keys2, memos, iterationType);
+      const result = objEquiv(val1, val2, mode, keys1, keys2, memos, iterationType);
       memos.deep = false;
       return result;
     }
@@ -465,7 +468,7 @@ function keyCheck(val1, val2, mode, memos, iterationType, keys2) {
     return originalSize === set.size;
   }
 
-  const areEq = objEquiv(val1, val2, mode, keys2, memos, iterationType);
+  const areEq = objEquiv(val1, val2, mode, keys1, keys2, memos, iterationType);
 
   set.delete(val1);
   set.delete(val2);
@@ -581,16 +584,34 @@ function setEquiv(a, b, mode, memo) {
   // This is a lazily initiated Set of entries which have to be compared
   // pairwise.
   let set = null;
-  for (const val of b) {
+  const iteratorB = b.values();
+  for (const val of iteratorB) {
     if (!a.has(val)) {
       if ((typeof val !== 'object' || val === null) &&
           (mode !== kLoose || !setMightHaveLoosePrim(a, b, val))) {
         return false;
       }
 
       if (set === null) {
-        if (a.size === 1) {
-          return innerDeepEqual(a.values().next().value, val, mode, memo);
+        if (a.size < 3) {
+          const iteratorA = a.values();
+          const firstA = iteratorA.next().value;
+          const first = innerDeepEqual(firstA, val, mode, memo);
+          if (first) {
+            if (b.size === 1) { // Partial mode && a.size === 1
+              return true;
+            }
+            const secondA = iteratorA.next().value;
+            return b.has(secondA) || innerDeepEqual(secondA, iteratorB.next().value, mode, memo);
+          }
+          if (a.size === 1) {
+            return false;
+          }
+          return innerDeepEqual(iteratorA.next().value, val, mode, memo) && (
+            b.size === 1 || // Partial mode
+            b.has(firstA) || // Primitive or reference equal
+            innerDeepEqual(firstA, iteratorB.next().value, mode, memo)
+          );
         }
         set = new SafeSet();
       }
@@ -770,11 +791,28 @@ function sparseArrayEquiv(a, b, mode, memos, i) {
   return true;
 }
 
-function objEquiv(a, b, mode, keys2, memos, iterationType) {
+function objEquiv(a, b, mode, keys1, keys2, memos, iterationType) {
   // The pair must have equivalent values for every corresponding key.
   if (keys2.length > 0) {
-    for (const key of keys2) {
-      if (!innerDeepEqual(a[key], b[key], mode, memos)) {
+    let i = 0;
+    // Ordered keys
+    if (keys1 !== undefined) {
+      for (; i < keys2.length; i++) {
+        const key = keys2[i];
+        if (keys1[i] !== key) {
+          break;
+        }
+        if (!innerDeepEqual(a[key], b[key], mode, memos)) {
+          return false;
+        }
+      }
+    }
+    // Unordered keys
+    for (; i < keys2.length; i++) {
+      const key = keys2[i];
+      const descriptor = ObjectGetOwnPropertyDescriptor(a, key);
+      if (!descriptor?.enumerable ||
+          !innerDeepEqual(descriptor.value !== undefined ? descriptor.value : a[key], b[key], mode, memos)) {
         return false;
       }
     }