User Rating 0.0 ★★★★★

Total Usage 0 times

Category Code Utilities

JavaScript Object / JSON Accepts valid JSON or JS object literals (no functions). Arrays are order-invariant.

Is this tool helpful?

Your feedback helps us improve.

★ ★ ★ ★ ★

About

Comparing two deeply nested JavaScript objects for structural equivalence is a non-trivial operation. A naive recursive equality check runs in O(n) time on every comparison and cannot be indexed or cached. This tool serializes any JSON-compatible object into a canonical form - sorting object keys lexicographically and normalizing array order - then computes the 128-bit MD5 digest per RFC 1321. The resulting 32-character hexadecimal string serves as a fingerprint: two objects produce identical hashes if and only if they are structurally equivalent (ignoring array element order). Objects containing function values at any depth are rejected, as functions lack a deterministic string representation.

The canonical serialization step is critical. Without it, {a:1, b:2} and {b:2, a:1} would produce different hashes despite logical equivalence. Similarly, arrays [1,2] and [2,1] are treated as identical sets. This makes the tool suitable for indexing object states in databases, cache invalidation keys, or regression test fixtures where insertion order is non-deterministic. The MD5 implementation here is pure JavaScript - no CryptoJS, no Underscore, no dependencies. Note: MD5 is not cryptographically secure for password hashing. It is used here strictly as a fast, compact fingerprint for equivalence testing.

Formulas

The MD5 algorithm processes an input message in 512-bit blocks. Each block undergoes 64 operations organized into 4 rounds of 16 operations. The four auxiliary functions are:

F(B, C, D) = (B ∧ C) ∨ (¬B ∧ D)

G(B, C, D) = (B ∧ D) ∨ (C ∧ ¬D)

H(B, C, D) = B &xor; C &xor; D

I(B, C, D) = C &xor; (B ∨ ¬D)

Each round operation follows the pattern:

a = b + ((a + F(b,c,d) + M_k + T_i) ≪≪≪ s)

where M_k is the k-th 32-bit word of the message block, T_i = floor(2³² × |sin(i)|) is the per-round constant, s is the per-round shift amount, and ≪≪≪ denotes left circular rotation. The initial hash values are a₀ = 0x67452301, b₀ = 0xEFCDAB89, c₀ = 0x98BADCFE, d₀ = 0x10325476.

The canonical serialization before hashing follows this logic: for an object, sort all keys alphabetically, recurse into each value, and concatenate as key:value pairs. For an array, recursively serialize each element, sort the serialized strings lexicographically, then join. This ensures both key-order invariance and array-order invariance.

Reference Data

Feature / Behavior	This Tool	Notes
Key order sensitivity	Order-invariant	Keys sorted lexicographically at every depth
Array order sensitivity	Order-invariant	Elements sorted by canonical serialized form
Nested objects	Fully recursive	No depth limit
Nested arrays	Fully recursive	Mixed types sorted by type then value
null values	Supported	Serialized as null
undefined values	Omitted	Matches JSON.stringify behavior
function values	Rejected	Error thrown with path to offending key
Boolean values	Supported	TRUE ≠ 1
Number precision	IEEE 754 double	0.1 + 0.2 ≠ 0.3
Empty object {}	99914b932bd37a50b983c5e7c90ae93b	MD5 of canonical {}
Empty array []	d751713988987e9331980363e24189ce	MD5 of canonical []
String encoding	UTF-8	Full Unicode support
Max safe integer	9007199254740991	Beyond this, precision loss may alter hash
Hash output length	32 hex characters	128 bits
Collision probability	≈ 1 in 2¹²⁸	Sufficient for equivalence testing
Algorithm	MD5 (RFC 1321)	Not suitable for cryptographic security
Dependencies	None	Pure vanilla JavaScript
Circular references	Rejected	Error thrown to prevent infinite recursion
NaN values	Serialized as null	Matches JSON.stringify behavior
Infinity values	Serialized as null	Matches JSON.stringify behavior

Frequently Asked Questions

The canonical serialization step sorts array elements by their serialized string representation before hashing. This deliberate design choice treats arrays as unordered sets for equivalence testing. If your use case requires order-sensitive comparison, this tool is not appropriate - you would need a serializer that preserves insertion order.

JavaScript functions lack a standardized, deterministic string representation. Two functionally identical closures can have different source text due to minification, variable renaming, or environment capture. Including them would produce unreliable hashes. Strip all function properties before hashing, or serialize only the data subset of your object.

Circular references (e.g., obj.self = obj) cause infinite recursion during serialization. The tool maintains a visited-object set and throws an error with the path to the circular reference if one is detected. You must break the cycle before hashing.

No. MD5 has known collision vulnerabilities (Wang & Yu, 2004) and is considered broken for cryptographic purposes. This implementation is strictly for fast structural fingerprinting of data objects. For security-sensitive hashing, use SHA-256 or bcrypt.

JavaScript represents numbers as IEEE 754 double-precision floats. The expression 0.1 + 0.2 evaluates to 0.30000000000000004, not 0.3. These will produce different hashes. If precision matters, round your numbers or use string representations before hashing.

Yes. Keys and string values are serialized as UTF-8 before MD5 computation. The lexicographic sort uses JavaScript's default string comparison, which operates on UTF-16 code units. Keys like "é" and "e\u0301" (composed vs. decomposed) will produce different hashes. Normalize Unicode (NFC/NFD) before hashing if this matters.

Properties with undefined values are omitted from serialization, matching the behavior of JSON.stringify. This means {a: undefined} hashes identically to {}. In contrast, null is explicitly serialized as the string null and contributes to the hash.