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

``bash
npm install deep-equal-check
`

Quick Start

$3


`typescript
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
`

$3


`javascript
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:

`bash
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

$3

- ✅ 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)

$3

- 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)

$3

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

License

MIT