Objects and Hash in NodeJS
In computer science, a hash function is a mathematical algorithm that takes in input data of arbitrary size and maps it to a fixed-size output value known as a hash or a digest. The hash function generates a unique digital fingerprint of the input data, which can be used for various purposes, such as data integrity verification, data encryption, data indexing, and data retrieval. Hash functions are designed to be fast and efficient, and they are commonly used in a variety of applications, including password storage, digital signatures, file verification, and network communication. A good hash function should produce a unique hash value for each distinct input, and it should be practically impossible to reverse the process and determine the original input data from the hash value.
Object-hash is a JavaScript library that generates a unique hash value for any JavaScript object. It is commonly used in web development for caching, indexing, and comparing objects. The library works by recursively iterating through the object and generating a hash value based on the object’s keys and values. The resulting hash value is a deterministic representation of the object, meaning that two objects with the same properties will always generate the same hash value. Object-hash supports various types of objects, including arrays, objects, functions, and primitives. It also has options for customizing the hash function, including the ability to exclude certain keys or use a custom hashing function for specific key-value pairs. Object-hash is available as a Node.js module and can also be used in web browsers. It is released under the MIT license and can be found on GitHub.
Usage of object-hash Object-hash can be used in various scenarios where you need to generate a unique identifier for a JavaScript object. Some common use cases include:
Caching: When you have a large dataset or a complex object, object-hash can be used to generate a hash value that can be used as a key to cache the object. This can improve the performance of your application by reducing the amount of time spent generating the object. Indexing: Object-hash can also be used to create an index of objects for efficient searching and retrieval. By storing the hash value along with the object, you can quickly search for objects using their hash values rather than iterating through the entire collection. Comparing objects: Object-hash can be used to compare two objects for equality. By comparing their hash values, you can quickly determine if two objects are identical without comparing each property. Serializing objects: Object-hash can also be used to serialize objects to a string or buffer that can be stored or transmitted over a network. The hash value can be used as a unique identifier for the object, making it easy to deserialize the object later.
- First, you generate a hash value for the list of blog posts using object-hash. The hash value will serve as the key to cache the object.
const objectHash = require('object-hash'); // Fetch the list of blog posts from the database or API const posts = await fetchPosts(); // Generate a hash value for the list of blog posts const hash = objectHash(posts); - Next, you check if the hash value already exists in the cache. If it does, you retrieve the cached object and use it to render the page. If it doesn’t, you generate the list of blog posts, store it in the cache using the hash value as the key, and use it to render the page.
// Check if the hash value exists in the cache if (cache.has(hash)) < // Retrieve the cached object const cachedPosts = cache.get(hash); // Use the cached object to render the page renderPage(cachedPosts); >else < // Generate the list of blog posts const posts = await fetchPosts(); // Store the list of blog posts in the cache cache.set(hash, posts); // Use the list of blog posts to render the page renderPage(posts); >By using object-hash to generate a unique hash value for the list of blog posts, you can easily check if the object already exists in the cache without having to compare the entire object. This can significantly improve the performance of your application by reducing the time spent generating or fetching data.
Saved searches
Use saved searches to filter your results more quickly
You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session. You switched accounts on another tab or window. Reload to refresh your session.
Generate hashes from javascript objects in node and the browser.
License
puleos/object-hash
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Name already in use
A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
Sign In Required
Please sign in to use Codespaces.
Launching GitHub Desktop
If nothing happens, download GitHub Desktop and try again.
Launching GitHub Desktop
If nothing happens, download GitHub Desktop and try again.
Launching Xcode
If nothing happens, download Xcode and try again.
Launching Visual Studio Code
Your codespace will open once ready.
There was a problem preparing your codespace, please try again.
Latest commit
Git stats
Files
Failed to load latest commit information.
readme.markdown
Generate hashes from objects and values in node and the browser. Uses node.js crypto module for hashing. Supports SHA1 and many others (depending on the platform) as well as custom streams (e.g. CRC32).
- Hash values of any type.
- Supports a keys only option for grouping similar objects with different values.
var hash = require('object-hash'); hash(foo: 'bar'>) // => '67b69634f9880a282c14a0f0cb7ba20cf5d677e9' hash([1, 2, 2.718, 3.14159]) // => '136b9b88375971dff9f1af09d7356e3e04281951'
Starting with version 1.1.8 (released April 2017), new versions will consider the exact returned hash part of the API contract, i.e. changes that will affect hash values will be considered semver-major . Previous versions may violate that expectation.
Generate a hash from any object or type. Defaults to sha1 with hex encoding.
- algorithm hash algo to be used: ‘sha1’, ‘md5’, ‘passthrough’. default: sha1
- This supports the algorithms returned by crypto.getHashes() . Note that the default of SHA-1 is not considered secure, and a stronger algorithm should be used if a cryptographical hash is desired.
- This also supports the passthrough algorith, which will return the information that would otherwise have been hashed.
Hash using the sha1 algorithm.
Note that SHA-1 is not considered secure, and a stronger algorithm should be used if a cryptographical hash is desired.
Sugar method, equivalent to hash(value, )
Hash object keys using the sha1 algorithm, values ignored.
Sugar method, equivalent to hash(value, )
Hash using the md5 algorithm.
Note that the MD5 algorithm is not considered secure, and a stronger algorithm should be used if a cryptographical hash is desired.
Sugar method, equivalent to hash(value, )
Hash object keys using the md5 algorithm, values ignored.
Note that the MD5 algorithm is not considered secure, and a stronger algorithm should be used if a cryptographical hash is desired.
hash.writeToStream(value, [options,] stream)
Write the information that would otherwise have been hashed to a stream, e.g.:
hash.writeToStream(foo: 'bar', a: 42>, respectType: false>, process.stdout) // => e.g. 'object:a:number:42foo:string:bar'
script src pl-s">object_hash.js" type pl-s">text/javascript">script> script> var hash = objectHash.sha1(foo:'bar'>); console.log(hash); // e003c89cdf35cdf46d8239b4692436364b7259f9 script>
var hash = require ( ‘object-hash’ ) ; var peter = < name : 'Peter' , stapler : false , friends : [ 'Joanna' , 'Michael' , 'Samir' ] >; var michael = < name : 'Michael' , stapler : false , friends : [ 'Peter' , 'Samir' ] >; var bob = < name : 'Bob' , stapler : true , friends : [ ] >; /*** * sha1 hex encoding (default) */ hash ( peter ) ; // 14fa461bf4b98155e82adc86532938553b4d33a9 hash ( michael ) ; // 4b2b30e27699979ce46714253bc2213010db039c hash ( bob ) ; // 38d96106bc8ef3d8bd369b99bb6972702c9826d5 /*** * hash object keys, values ignored */ hash ( peter , < excludeValues : true >) ; // 48f370a772c7496f6c9d2e6d92e920c87dd00a5c hash ( michael , < excludeValues : true >) ; // 48f370a772c7496f6c9d2e6d92e920c87dd00a5c hash . keys ( bob ) ; // 48f370a772c7496f6c9d2e6d92e920c87dd00a5c /*** * hash object, ignore specific key(s) */ hash ( peter , < excludeKeys : function ( key ) < if ( key === 'friends' ) < return true ; >return false ; > > ) ; // 66b7d7e64871aa9fda1bdc8e88a28df797648d80 /*** * md5 base64 encoding */ hash ( peter , < algorithm : 'md5' , encoding : 'base64' >) ; // 6rkWaaDiG3NynWw4svGH7g== hash ( michael , < algorithm : 'md5' , encoding : 'base64' >) ; // djXaWpuWVJeOF8Sb6SFFNg== hash ( bob , < algorithm : 'md5' , encoding : 'base64' >) ; // lFzkw/IJ8/12jZI0rQeS3w==
git clone https://github.com/puleos/object-hashIf you want to stand this up in a docker container, you should take at look at the project.
- gulp watch (default) watch files, test and lint on change/add
- gulp test unit tests
- gulp karma browser unit tests
- gulp lint jshint
- gulp dist create browser version in /dist
Only Node.js versions >= 6.0.0 are being tested in CI now. No other breaking changes were introduced.
About
Generate hashes from javascript objects in node and the browser.