Benchmark: hash-sum vs object-hash opttimized 2

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/npm/hash-sum@2.0.0/hash-sum.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/object-hash@2.0.3/dist/object_hash.min.js"></script>

Script Preparation code:

var context1 = {
  title: 'fish',
  position: 1
}

Tests:

Sum
sum(context1)
Object-hash
objectHash(context1,{algorithm:'sha1',encoding:'hex', excludeKeys(key) { return !context1.hasOwnProperty(key); },})

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Sum
Object-hash

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36

Browser/OS: Chrome 128 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Sum	866102.4 Ops/sec
Object-hash	170470.2 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

The benchmark in question is comparing two approaches to hashing and summing data: `hash-sum` and `object-hash`. The test cases are designed to measure the performance difference between these two methods.

**Hash-Sum Approach**

The hash-sum approach uses a library called `hash-sum` (version 2.0.0) to calculate the sum of the values in an object. This library is likely implementing a variant of the MurmurHash algorithm, which is a widely used hashing function for its performance and security properties.

In this specific benchmark, the test case `Sum` measures the execution time of the following code:
```javascript
var context1 = {
  title: 'fish',
  position: 1
}
sum(context1)
```
The `sum` function is expected to iterate over each property in the object and calculate its hash value using the `hash-sum` library. The resulting hashes are then summed up to produce the final result.

**Object-Hash Approach**

The object-hash approach uses a library called `object-hash` (version 2.3) to calculate the hash of an object. This library provides more advanced features, such as support for different hashing algorithms and encoding schemes.

In this benchmark, the test case `Object-hash` measures the execution time of the following code:
```javascript
var context1 = {
  title: 'fish',
  position: 1
}
objectHash(context1, {
  algorithm: 'sha1',
  encoding: 'hex',
  excludeKeys(key) {
    return !context1.hasOwnProperty(key);
  }
})
```
The `objectHash` function is expected to take the object `context1` and apply the specified hashing algorithm (SHA-1 in this case), encoding scheme (hex), and exclusion rules (only consider properties that exist on the original object). The resulting hash value is then returned.

**Comparison of Options**

Both approaches have their pros and cons:

* **Hash-Sum Approach:**
	+ Pros:
		- Simpler implementation, potentially easier to understand and maintain.
		- Fast execution times due to the optimized MurmurHash algorithm.
	+ Cons:
		- May not provide as much flexibility or customization options as the object-hash approach.
* **Object-Hash Approach:**
	+ Pros:
		- More flexible and customizable, allowing for different hashing algorithms and encoding schemes.
		- Can handle more complex scenarios, such as excluding specific properties or applying custom logic.
	+ Cons:
		- More complex implementation, potentially harder to understand and maintain.
		- May have slower execution times due to the additional overhead.

**Other Considerations**

When choosing between these approaches, consider the following factors:

* **Performance:** If speed is crucial, the hash-sum approach might be a better choice. However, if flexibility and customization are more important, the object-hash approach might be a better fit.
* **Complexity:** If you need to handle complex scenarios or require fine-grained control over the hashing process, the object-hash approach is likely a better option.

**Alternative Libraries**

Other libraries for hash calculation and summing data include:

* `hashjs`: A lightweight library providing multiple hashing algorithms, including SHA-1, SHA-256, and others.
* `crypto-js`: A popular library offering various cryptographic functions, including hashing and encoding schemes.
* `lodash.hashing`: A part of the Lodash utility library, providing a range of hash-related functions.

These libraries can be used as alternatives to `hash-sum` and `object-hash`, but may have different features, performance characteristics, or complexity levels.

Related benchmarks:

hash-sum vs object-hash opttimized 2 (version: 0)

Comparing performance of: Sum vs Object-hash

Created: 2 years ago by: Registered User

Jump to the latest result

Sum

Object-hash

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):