ohash

You can import the core functions or the utility functions using ESM or dynamic imports. The core functions are available from ohash, while diff is available from ohash/utils.

// ESM import
import { hash, serialize, digest, isEqual } from "ohash";
import { diff } from "ohash/utils";

// Dynamic import
const { hash, serialize, digest, isEqual } = await import("ohash");
const { diff } = await import("ohash/utils");

You can install ohash using npx nypm which will auto-detect your package manager (npm, yarn, pnpm, bun, or deno).

npx nypm i ohash

The serialize(input) function converts an input value into a string representation used for hashing.

IMPORTANT

serialize uses best efforts to generate stable values, but it is not designed for security purposes. It may be susceptible to intentional collisions via user input.

import { serialize } from "ohash";

// "{foo:'bar'}"
console.log(serialize({ foo: "bar" }));

The diff(obj1, obj2) utility function compares two objects using nested serialization and returns an array of changes. Each entry in the returned array contains $key, $hash, $value, and $props. When logged, it displays a human-readable changelog string.

import { diff } from "ohash/utils";

const createObject = () => ({
  foo: "bar",
  nested: {
    y: 123,
    bar: {
      baz: "123",
    },
  },
});

const obj1 = createObject();
const obj2 = createObject();

obj2.nested.x = 123;
delete obj2.nested.y;
obj2.nested.bar.baz = 123;

const diff = diff(obj1, obj2);

// [-] Removed nested.y
// [~] Changed nested.bar.baz from "123" to 123
// [+] Added   nested.x
console.log(diff(obj1, obj2));

The digest(str) function hashes a string using the SHA-256 algorithm and encodes the output in Base64URL format.

import { digest } from "ohash";

// "f4OxZX_x_FO5LcGBSKHWXfwtSx-j1ncoSt3SABJtkGk"
console.log(digest("Hello World!"));

The isEqual(obj1, obj2) function compares two objects. It first attempts a strict equality check (===) and falls back to comparing their serialized values if the strict check fails.

import { isEqual } from "ohash";

// true
console.log(isEqual({ a: 1, b: 2 }, { b: 2, a: 1 }));

The hash(input) function converts any JavaScript value into a string hash. It works by first serializing the input and then digesting the result.

import { hash } from "ohash";

// "g82Nh7Lh3CURFX9zCBhc5xgU0K7L0V1qkoHyRsKNqA4"
console.log(hash({ foo: "bar" }));

The serialize(input) function converts any JavaScript value into a stable string representation suitable for hashing. This is useful when you need a consistent string identifier for complex objects, arrays, or primitives.

Important Security Note: This method is designed for stability, not security. It is not intended for cryptographic purposes and is susceptible to intentional collisions via user input.

Supported types and their serialization styles include:

• Strings: Wrapped in single quotes (e.g., 'hello').
• BigInt: Appended with n (e.g., 10n).
• Null: Returns `

The diff(obj1, obj2) function compares two objects and returns an array of DiffEntry objects representing the changes. It identifies whether properties were added, removed, or changed by traversing the object structure and comparing their hashed representations.

import { diff } from "ohash";

const obj1 = { a: 1, b: { c: 2 } };
const obj2 = { a: 1, b: { c: 3 }, d: 4 };

const differences = diff(obj1, obj2);
// Returns an array of DiffEntry objects describing the changes to 'b.c' and 'd'

The isEqual function performs a comparison between two values using a two-step process: first, it checks for strict reference equality (===), and if that fails, it checks for equality using stable deep hashing via serialize(). This ensures that two different object instances with the same structure and values are considered equal.

import { isEqual } from 'ohash';

const obj1 = { a: 1, b: { c: 2 } };
const obj2 = { a: 1, b: { c: 2 } };

// Returns true because they are structurally identical
isEqual(obj1, obj2); 

The hash function converts any JavaScript value into a unique string hash. It works by first serializing the input value and then applying a cryptographic digest to the resulting string. This is useful for creating stable identifiers for complex objects, arrays, or primitives.

import { hash } from 'ohash'

const myHash = hash({ a: 1, b: [1, 2, 3] })
// returns a string hash

Use the hash function to generate a hash of a given input. This is typically used for creating unique identifiers for data structures.

import { hash } from 'ohash';

const h = hash({ a: 1, b: 2 });