Benchmark: object-hash md5 vs JSON.stringify33

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,
    array: [1, 2, 3, [4, 5, 6]],
}

var context2 = {
    title: 'fish',
    position: 1,
    array: [1, 2, 3, [4, 5, 6]],
    array2: [{}, {}, {}],
}

Tests:

JSON.stringify
JSON.stringify(context1) === JSON.stringify(context2)
md5
objectHash(context1, { algorithm: "sha1", encoding: "base64", unorderedArrays: true, unorderedSets: true, unorderedObjects: true, }) === objectHash(context2, { algorithm: "sha1", encoding: "base64", unorderedArrays: true, unorderedSets: true, unorderedObjects: true, })

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
JSON.stringify
md5

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 25 days ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:136.0) Gecko/20100101 Firefox/136.0

Browser/OS: Firefox 136 on Mac OS X 10.15

View result in a separate tab

Test name	Executions per second
JSON.stringify	2622812.0 Ops/sec
md5	9796.3 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 5 months ago):

LLMs can make mistakes. Check important info.

The benchmark presented compares two different methods of generating hashes for JavaScript objects: using `JSON.stringify` and using the `object-hash` library. Below is a detailed breakdown of what is being tested, the options compared, along with the pros and cons of each approach, and some additional considerations.

### What is Tested
The benchmark involves two separate test cases:
1. **JSON.stringify**
   - The first test case evaluates whether the string representations of the two JavaScript objects (`context1` and `context2`) are equal when both are passed through `JSON.stringify`.
  
2. **object-hash**
   - The second test case uses the `object-hash` library to create hashes of the same two objects while applying specific options like using SHA1 as the algorithm and encoding the result as base64.

### Options Compared
- **Method 1: JSON.stringify**
  - This built-in JavaScript function converts a JavaScript object into a JSON string. It is commonly used for serialization but has limitations, especially when it comes to handling certain data types and maintaining order.
  
- **Method 2: object-hash**
  - This library provides a means for generating stable hashes of JavaScript objects. It allows for various configuration options, such as specifying the hashing algorithm (in this case, SHA1) and options for ignoring the order of properties in arrays and objects.

### Pros and Cons

#### JSON.stringify
*Pros:*
- **Native**: Being built into JavaScript means no external dependencies, making it universally available in all JavaScript environments.
- **Simplicity**: Easy to use for quick serialization and comparison.

*Cons:*
- **Non-Unique Representations**: The same object can yield different string representations, particularly with respect to object property order and the handling of non-serializable values (e.g., functions, `undefined`).
- **Performance**: Serializing large or deeply nested objects can be performance-intensive, especially if deep copies are made during stringification.

#### object-hash
*Pros:*
- **Stability**: The library can produce consistent hashes for equivalent objects irrespective of property order or value types (due to configuration options).
- **Configurability**: Options for customizing behavior (e.g., hash algorithm, encoding, and handling of unordered collections) add flexibility.

*Cons:*
- **Additional Dependencies**: Requires importing an external library, which may be a concern for lightweight applications or environments with strict dependency management.
- **Overhead**: Depending on the library's implementation, there may be additional performance overhead compared to using native functions, particularly with more complex options.

### Libraries and Features
- **object-hash**: This library is used for creating unique and consistent hash values from JavaScript objects. Its primary purpose is to facilitate easy comparisons of complex data structures, making it useful in scenarios like caching, state management, and more.
- **hash-sum** (implied, as part of the setup but not directly used in the tests): This library serves a similar purpose but might focus on simpler use cases where a straightforward hash is produced without many configuration options.

### Additional Considerations
- **Performance Metrics**: The benchmark results show significant differences in performance. For instance, `JSON.stringify` managed around 1.77 million executions per second, while `object-hash` fared much worse with about 8,725 executions per second. This discrepancy underscores the performance trade-offs between built-in methods and more specialized libraries.
- **Use Cases**: Depending on the requirements (e.g., performance, need for stable hashes vs. simple serialization), developers may favor one method over another. For situations where performance is key, `JSON.stringify` might be preferred for straightforward tasks. However, if object equality checks or configurability is paramount, `object-hash` offers significant advantages despite its slower performance.

### Other Alternatives
- **Lodash**: Libraries like Lodash provide deep comparison functions, which can be helpful to determine equality but do not generate hashes. They can be used alongside `JSON.stringify` for complex comparisons.
- **Deep Equal Libraries**: There are specialized libraries (e.g., `assert.deepEqual` in Node.js) that can check for deep equality without needing serialization.
- **Custom Functions**: Developers may write their own serialization or hashing functions tailored to specific application needs.

This benchmark serves as a practical exploration of these two methods, highlighting their performance implications and how they can be applied depending on the requirements of the application.

Related benchmarks:

object-hash md5 vs JSON.stringify33 (version: 1)

Comparing performance of: JSON.stringify vs md5

Created: 5 months ago by: Guest

Jump to the latest result

JSON.stringify

md5

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 5 months ago):