Avoid expensive DeepChecker instance property initializations.

Author: benjamn

packages/equality/src/checker.ts

@@ -51,19 +51,59 @@ const CHECKERS_BY_TAG = new Map<string, Checker<any>>()
   .set('[object AsyncGeneratorFunction]', checkFunctions)
   .set('[object Function]', checkFunctions);
 
+type ComparisonTrie = Trie<{
+  equal?: boolean;
+}>;
+
+// Initializing checker.comparisons and checker.boundCheck as proper members of
+// the DeepChecker class makes creating DeepChecker objects considerably more
+// expensive in some environments, even if we initialize them to null and then
+// upgrade them lazily, when needed. Instead, we store these two items of state
+// in a separate Map, which gets cleaned up in the DeepChecker#release method.
+const privateStateMap = new Map<DeepChecker, {
+  comparisons?: ComparisonTrie;
+  boundCheck?: DeepEqualsHelper;
+}>();
+
+function getPrivateState(checker: DeepChecker) {
+  let state = privateStateMap.get(checker)!;
+  if (!state) privateStateMap.set(checker, state = Object.create(null));
+  return state;
+}
+
+function getComparisons(checker: DeepChecker): ComparisonTrie {
+  const state = getPrivateState(checker);
+  return state.comparisons || (state.comparisons = new Trie(false));
+}
+
 function getBoundCheck(checker: DeepChecker): DeepEqualsHelper {
-  return checker["boundCheck"] || (checker["boundCheck"] = function (a, b) {
-    return checker.check(a, b);
-  });
+  const state = getPrivateState(checker);
+  return state.boundCheck || (
+    state.boundCheck = (a, b) => checker.check(a, b)
+  );
 }
 
+const checkerPool: DeepChecker[] = [];
+const CHECKER_POOL_TARGET_SIZE = 5;
+
 export class DeepChecker {
-  // Initialized lazily because not always needed.
-  private comparisons: null | Trie<{ equal?: boolean; }> = null;
+  // Use DeepChecker.acquire() instead of new DeepChecker.
+  protected constructor() {}
 
-  // Initialized lazily because needed only when custom deepEqualsMethod methods
-  // are in use.
-  private boundCheck: null | DeepEqualsHelper = null;
+  static acquire() {
+    return checkerPool.pop() || new DeepChecker();
+  }
+
+  public release() {
+    // If privateStateMap was a WeakMap, we wouldn't necessarily need to perform
+    // this cleanup, but not all environments have a (performant) implementation
+    // of WeakMap, and the cleanup is easy enough:
+    privateStateMap.delete(this);
+
+    if (checkerPool.length < CHECKER_POOL_TARGET_SIZE) {
+      checkerPool.push(this);
+    }
+  }
 
   public check(a: any, b: any): boolean {
     // If the two values are strictly equal, our job is easy.
@@ -89,9 +129,7 @@ export class DeepChecker {
 
     const found =
       bothNonNullObjects &&
-      (this.comparisons || (
-        this.comparisons = new Trie(false)
-      )).lookup(a, b);
+      getComparisons(this).lookup(a, b);
 
     // Though cyclic references can make an object graph appear infinite from
     // the perspective of a depth-first traversal, the graph still contains a

packages/equality/src/equality.ts

@@ -4,7 +4,13 @@ import { DeepChecker } from "./checker";
  * Performs a deep equality check on two JavaScript values, tolerating cycles.
  */
 export function equal(a: any, b: any): boolean {
-  return a === b || new DeepChecker().check(a, b);
+  if (a === b) return true;
+  const checker = DeepChecker.acquire();
+  try {
+    return checker.check(a, b);
+  } finally {
+    checker.release();
+  }
 }
 
 // Allow default imports as well.