Benchmark: indexof vs hash - MeasureThat.net

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.19/lodash.core.min.js"></script>

Script Preparation code:

assets = [
{ md5: 'aaa'},
{ md5: 'aaa'},
{ md5: 'aaa'},
{ md5: 'aaa'},
{ md5: 'aaa'},
{ md5: 'aaa'},
{ md5: 'aaa'},
{ md5: 'aaa'},
{ md5: 'aaa'},
{ md5: 'aaa'},
{ md5: 'aaa'},
{ md5: 'aaa'},
{ md5: 'aaa'},
{ md5: 'aaa'},
{ md5: 'aaa'},
{ md5: 'bbbb'},
{ md5: 'bbbb'},
{ md5: 'bbbb'},
{ md5: 'bbbb'},
{ md5: 'bbbb'},
{ md5: 'bbbb'},
{ md5: 'bbbb'},
{ md5: 'bbbb'},
{ md5: 'ccc'},
{ md5: 'ccc'},
{ md5: 'ccc'},
{ md5: 'ccc'},
{ md5: 'ccc'},
{ md5: 'ccc'},
{ md5: 'ccc'},
{ md5: 'ccc'},
{ md5: 'ccc'},
{ md5: 'ccc'},
{ md5: 'ccc'},
{ md5: 'ccc'},
{ md5: 'ccc'},
{ md5: 'ccc'},
{ md5: 'ccc'},
{ md5: 'aaa'},
{ md5: 'aaa'},
{ md5: 'aaa'},
{ md5: 'aaa'},
{ md5: 'aaa'},
{ md5: 'aaa'},
{ md5: 'abc'},
{ md5: 'abc'},
{ md5: 'abc'},
{ md5: 'abc'},
{ md5: 'abc'},
{ md5: 'abc'},
{ md5: 'abc'},
{ md5: 'abc'},
{ md5: 'abc'},
{ md5: 'abc'},
{ md5: 'abc'},
{ md5: 'abc'},
{ md5: 'abc'},
{ md5: 'abc'},
{ md5: 'abc'},
{ md5: 'abc'},
{ md5: 'abc'},
{ md5: 'abc'},
{ md5: 'abc'},
{ md5: 'abc'},
{ md5: 'abc'}
];

Tests:

indexof
var uniqAssets = []; var uniqAssetsMd5s = []; assets.forEach(function (assetDAO) { if (_.indexOf(uniqAssetsMd5s, assetDAO.md5) < 0) { uniqAssets.push(assetDAO); uniqAssetsMd5s.push(assetDAO.md5); } });
hash
const md5 = {}; assets.forEach((assetDAO) => { if (!md5[assetDAO.md5]) { md5[assetDAO.md5] = assetDAO; } }); return Object.values(md5);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
indexof
hash

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

I'll break down what's being tested in the provided benchmark.

**What is being tested?**

The benchmark tests two approaches to find unique elements in an array: `indexof` and `hash`. The array contains objects with a `md5` property, which represents the MD5 hash of a string.

**Options compared**

Two options are compared:

1. **Index of**: This approach uses the `_.indexOf()` function from Lodash to find the index of each unique `md5` value in the `uniqAssetsMd5s` array.
2. **Hash**: This approach uses an object (`md5`) to keep track of unique values, where each key is a `md5` value and its corresponding value is the original `assetDAO` object.

**Pros and Cons**

**Index of:**

Pros:

* Simple and easy to understand
* Fast execution ( likely due to the optimized implementation of `_.`indexOf()` )

Cons:

* May have performance issues if the array is very large or has many duplicate values
* Requires Lodash library, which may add overhead

**Hash:**

Pros:

* Efficient use of memory, as only unique `md5` values are stored in the object
* Fast execution ( likely due to the optimized implementation of the object lookup )

Cons:

* More complex and harder to understand than the index of approach
* May require more computational resources to create the object

**Other considerations**

* The benchmark uses a relatively small array with 24 elements, which may not be representative of larger datasets.
* The `assets` array contains both duplicate and unique values, which may affect the performance characteristics of each approach.

**Library**

The Lodash library is used in the benchmark. Specifically, the `_.`indexOf()` function is used in the "Index of" test case. Lodash is a popular utility library for JavaScript that provides various helper functions, including `indexOf()`, for working with arrays and objects.

No special JavaScript features or syntax are mentioned in the benchmark. The code uses standard ES6 syntax and requires no specific browser features or plugins to run.

**Alternatives**

Other alternatives to implement unique element finding could be:

* Using a Set data structure (e.g., `new Set()` )
* Implementing a custom algorithm using bitwise operations or other optimized techniques
* Using a more specialized library, such as `fast-unique` or ` uniq`
* Using a different approach altogether, such as sorting the array and removing duplicates

However, without knowing the specific requirements and constraints of the project, it's difficult to recommend an alternative that would outperform these two approaches.

Related benchmarks:

indexof vs hash (version: 0)

Comparing performance of: indexof vs hash

Created: 5 years ago by: Guest

Jump to the latest result

indexof

hash

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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