deep-equal-check

Fast deep equality checker for modern JavaScript and TypeScript – robust, configurable, and safe for all data types.

Features

• 3-10x faster than popular alternatives (16.7M ops/sec)
• Zero dependencies - completely self-contained
• TypeScript first - comprehensive type definitions
• Highly configurable - customizable comparison options
• Circular reference safe - prevents infinite recursion
• Universal - works in Node.js, browsers, JavaScript & TypeScript projects
• Hybrid optimization - combines fast paths with robust structure

Installation

npm install deep-equal-check

Quick Start

TypeScript/ES Modules

import deepEqualCheck from 'deep-equal-check';

// Basic usage
deepEqualCheck({a: 1}, {a: 1}); // true
deepEqualCheck([1, 2, 3], [1, 2, 3]); // true

// Complex objects
const obj1 = { 
  date: new Date('2023-01-01'),
  regex: /test/gi,
  set: new Set([1, 2, 3]),
  map: new Map([['key', 'value']])
};
const obj2 = { 
  date: new Date('2023-01-01'),
  regex: /test/gi,
  set: new Set([1, 2, 3]),
  map: new Map([['key', 'value']])
};
deepEqualCheck(obj1, obj2); // true

JavaScript/CommonJS

const deepEqualCheck = require('deep-equal-check');

// Basic usage
deepEqualCheck({a: 1}, {a: 1}); // true
deepEqualCheck([1, 2, 3], [1, 2, 3]); // true

// With options
deepEqualCheck(NaN, NaN, { nanEqual: true }); // true
deepEqualCheck(+0, -0, { strictZero: true }); // false

Performance

Run the built-in benchmark:

npm run benchmark

Architecture

The library uses a hybrid optimization strategy that combines:

• Fast inline paths for primitives, arrays, dates, and regex
• Modular structure for complex cases (sets, maps, objects)
• Order-independent comparisons for collections
• Circular reference detection with proper WeakMap handling

Supported Types

• ✅ Primitives (numbers, strings, booleans, null, undefined)
• ✅ Arrays (including nested and mixed types)
• ✅ Objects (plain objects, custom constructors)
• ✅ ES6+ Types (Set, Map, TypedArray, ArrayBuffer)
• ✅ Built-in Objects (Date, RegExp, Error)
• ✅ Boxed Primitives (String, Number, Boolean)
• ✅ Circular References (with infinite recursion protection)

Performance Results

• 28.4M operations/second - Primitives (same)
• 19.2M operations/second - Primitives (different)
• 9.0M operations/second - Mixed operations (complex cases)
• 6.4x faster than lodash/isEqual (complex cases)
• 4.8x faster than deep-eql (complex cases)
• Competitive with fast-deep-equal (with circular reference support)
• Strong performance on complex data types (Sets, Maps, nested objects)

Run Comparative Benchmarks

npx ts-node --project benchmark/tsconfig.json benchmark/compare-libraries.ts

License

MIT