hash-it

What is hash-it?

The hash-it npm package is a utility for creating unique hash values from JavaScript objects. It is particularly useful for creating hash keys for complex objects, ensuring that the same object will always produce the same hash value.

What are hash-it's main functionalities?

Hashing Objects

This feature allows you to generate a unique hash value for a given JavaScript object. The same object will always produce the same hash value, which is useful for caching or quick comparisons.

const { hash } = require('hash-it');
const obj = { a: 1, b: 2 };
const hashValue = hash(obj);
console.log(hashValue);

Hashing Arrays

This feature allows you to generate a unique hash value for an array. It ensures that the same array will always produce the same hash value, which can be useful for array comparisons or caching.

const { hash } = require('hash-it');
const arr = [1, 2, 3];
const hashValue = hash(arr);
console.log(hashValue);

Hashing Nested Structures

This feature allows you to generate a unique hash value for nested structures, including objects within objects and arrays within objects. It ensures consistency in hash values for complex data structures.

const { hash } = require('hash-it');
const nestedObj = { a: { b: 2 }, c: [1, 2, 3] };
const hashValue = hash(nestedObj);
console.log(hashValue);

Other packages similar to hash-it

object-hash

The object-hash package provides similar functionality to hash-it by generating unique hash values for JavaScript objects. It supports a variety of hashing algorithms and can handle complex nested structures. Compared to hash-it, object-hash offers more customization options for the hashing process.

hasha

The hasha package is a versatile hashing utility that supports multiple hashing algorithms like MD5, SHA-1, and SHA-256. While it is not specifically designed for hashing objects, it can be used to hash strings, buffers, and other data types. It is more general-purpose compared to hash-it.

crypto

The built-in Node.js crypto module provides a wide range of cryptographic functionalities, including hashing. While it is more complex and requires more setup to hash objects compared to hash-it, it offers extensive options for cryptographic operations and is highly customizable.

README

hash-it

Fast and consistent hashCode for any object type

Installation

$ npm i hash-it --save

Usage

// ES2015
import hashIt from 'hash-it';

// CommonJS
const hashIt = require('hash-it');

// script
const hashIt = window.hashIt;

const hashedObject = hashIt({
  foo: 'bar'
});

console.log(hashedObject);
// 2196683918

Overview

hashIt has a simple goal: provide a fast and consistent hashCode for any object type that is uniquely based on its values. This has a number of uses such as duplication prevention or fast equality comparisons.

Any object type?

Yes, any object type. Primitives, ES2015 classes like Symbol, DOM elements (yes, you can even hash the window object if you want). Any object type.

With no exceptions?

Well ... sadly, no, there are a few exceptions.

• Math
• WeakMap
• WeakSet

In the case of Math, it's not a constructor (really just a parent for methods), so there are no values to hash. In the case of both WeakMap and WeakSet, the spec explicitly forbids iteration over them, so the unique values cannot be discovered. In each of these three cases, no matter what the contents of the object, they will always yield the same hash result, which is unique to each object type.

Here is the list of object classes that have been tested and shown to produce unique hashCodes:

• Array
• ArrayBuffer
• Boolean
• Date (based on valueOf)
• Error (based on message)
• Float32Array
• Float64Array
• Function (based on name and arguments)
• Int8Array
• Int16Array
• Int32Array
• HTMLElement (based on innerHTML, includes all sub-types, e.g. HTMLAnchorElement, HTMLDivElement, etc)
• Map
• Null
• Number
• Object (can handle recursive objects)
• RegExp
• Set
• String
• Symbol
• Uint8Array
• Uint8ClampedArray
• Uint16Array
• Uint32Array
• Undefined
• Window

This is basically all I could think of, but if I have missed an object class let me know and I will add it!

Gotchas

While the hashes will be consistent when calculated within the same browser environment, there is no guarantee that the hashCode will be the same across different browsers due to browser-specific implementations of features. A vast majority of the time things line up, but there are some edge cases that cause differences, so just something to be mindful of.

Support

hashIt has been tested on the following browsers:

• Chrome
• Firefox
• Opera
• Edge
• IE9+

There are no DOM dependencies, so hashIt should work in Node as well.

Development

Standard stuff, clone the repo and npm i to get the dependencies. npm scripts available:

• build => builds the distributed JS with NODE_ENV=development and with sourcemaps
• build-minified => builds the distributed JS with NODE_ENV=production and minified
• compile-for-publish => runs the lint, test, transpile, dist scripts
• dev => runs the webpack dev server for the playground
• dist => runs the build and build-minified
• lint => runs ESLint against files in the src folder
• prepublish => if in publish, runs compile-for-publish
• test => run ava with NODE_ENV=test
• test:watch => runs test but with persistent watcher
• transpile => runs Babel against files in src to files in lib

Changelog

1.0.0

• Initial release