Benchmark: object-hash md5 vs JSON.stringify

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: "md5", encoding: "base64", unorderedArrays: true, unorderedSets: true, unorderedObjects: true, }) === objectHash(context2, { algorithm: "md5", 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: 15 days ago)

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

Browser/OS: Chrome 131 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
JSON.stringify	2917167.0 Ops/sec
md5	10681.5 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark definition and explain what's being tested, compared, and considered.

**Benchmark Overview**

The MeasureThat.net website provides a platform for users to create and run JavaScript microbenchmarks. In this case, we have two test cases: `JSON.stringify` and `md5`. The goal is to compare the performance of these two approaches in generating hashes from a given object.

**Test Case 1: JSON.stringify**

This test case creates two objects, `context1` and `context2`, which are identical except for an additional property `array2` in one of them. The benchmark definition is:

`JSON.stringify(context1) === JSON.stringify(context2)`

In this case, the test is checking if the stringified representation of both objects is equal.

**Test Case 2: md5**

This test case also uses the same two objects but applies a custom hashing function `objectHash` with specific parameters. The benchmark definition is:

`objectHash(context1, {\r\n      algorithm: \"md5\",\r\n      encoding: \"base64\",\r\n      unorderedArrays: true,\r\n      unorderedSets: true,\r\n      unorderedObjects: true,\r\n    }) \r\n  === objectHash(context2, {\r\n      algorithm: \"md5\",\r\n      encoding: \"base64\",\r\n      unorderedArrays: true,\r\n      unorderedSets: true,\r\n      unorderedObjects: true,\r\n    })`

Here, the test is checking if the output of the `objectHash` function with the specified parameters for both objects is equal.

**Comparison and Considerations**

The two approaches being compared are:

1. **Stringification**: This approach converts the object to a string using `JSON.stringify()`. The resulting strings can be compared directly.
2. **Hashing**: This approach uses a custom hashing function `objectHash` that generates a hash value for the object based on a specific algorithm (in this case, MD5) and encoding (base64).

**Pros and Cons**

* **Stringification**:
	+ Pros: Simple, easy to implement, and widely supported.
	+ Cons: May not be suitable for large or complex objects due to performance issues with string creation and comparison.
* **Hashing**:
	+ Pros: Can generate a fixed-size hash value that can be used for data integrity and security purposes.
	+ Cons: Requires additional dependencies (e.g., `object-hash` library), and the hashing algorithm may not be suitable for all use cases.

**Libraries and Dependencies**

In this benchmark, two libraries are used:

1. **`object-hash`**: This is a custom hashing function that generates hash values for objects based on a specific algorithm and encoding.
2. **`hash-sum`**: Although not directly used in the benchmark, it's likely included as a dependency for testing purposes.

**Special JavaScript Features/Syntax**

There are no special JavaScript features or syntax mentioned in this benchmark. However, it's worth noting that the `objectHash` library uses some advanced concepts like unordered arrays and sets to improve performance.

**Alternatives**

If you need alternative approaches for generating hashes from objects, consider the following:

1. **Built-in `crypto` module**: Many browsers support the `crypto` module, which provides functions for generating hash values.
2. **Other hashing libraries**: There are many other hashing libraries available that can be used as alternatives to `object-hash`, such as `crypto-js` or `sha512`.

Keep in mind that the choice of approach depends on your specific use case and requirements.

Related benchmarks:

object-hash md5 vs JSON.stringify (version: 0)

Comparing performance of: JSON.stringify vs md5

Created: one year 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 llama3.2:3b, generated 2 months ago):