Benchmark: uniqBy performance lodash vs native

HTML Preparation code:

<script>https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.15/lodash.core.js</script>

Script Preparation code:

var data = [{a: 1}, {a: 2}, {a: 3}, {a: 4}, {a: 5}, {a: 6}, {a: 7}, {a: 8}, {a: 1}];

Tests:

lodash
_.uniqBy(data, 'a');
javascript
const sortBy = (key) => { return (a, b) => (a[key] > b[key]) ? 1 : (b[key] > a[key] ? -1 : 0); }; const uniqBy = (arr, a) => { arr.sort(sortBy(a)); const arr1 = []; arr1.push(arr[0]); for (let index = 1; index < arr.length; index++) { if (arr[index-1] && arr[index -1].a !== arr[index].a) { arr1.push(arr[index]); } } return arr1; } uniqBy(data, 'a')
native
function uniqueBy(arr, prop){ const record = [] const seen = {} for (let i = 0, len = arr.length; i < len; ++i) { // Notice the len = arr.length const item = arr[i] const val = item[prop] if (!seen[val]) { seen[val] = 1 record.push(item) } } } uniqueBy(data, 'a')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash
javascript
native

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the world of MeasureThat.net and explore what's being tested in this benchmark.

**Overview**

The benchmark is designed to compare the performance of three approaches to remove duplicates from an array:

1. **Lodash**: A popular JavaScript library that provides a `uniqBy` function for removing duplicates based on a specified property.
2. **Native JavaScript**: A custom implementation of the `uniqBy` function using only standard JavaScript features.
3. **Other alternative (not shown in this benchmark)**: An unknown approach that is not implemented here.

**Options being compared**

The main options being compared are:

1. **Lodash**: Uses the `lodash.core.js` library to provide the `uniqBy` function.
2. **Native JavaScript**: Implements the `uniqBy` function using standard JavaScript features, such as sorting and iterating over the array.

**Pros and Cons of each approach**

1. **Lodash**:
	* Pros: Easy to use, well-tested, and widely adopted library.
	* Cons: Adds an external dependency (the library), which may slow down execution or cause issues with other libraries.
2. **Native JavaScript**:
	* Pros: No external dependencies, highly optimized for performance, and leverages the browser's built-in sorting algorithm.
	* Cons: Requires more manual effort to implement, and may not be as readable or maintainable as a library.

**Library explanation**

In this benchmark, `lodash` is used as a library to provide the `uniqBy` function. Lodash is a popular JavaScript utility library that provides a wide range of functions for tasks such as string manipulation, array manipulation, and more. In this case, the `uniqBy` function is specifically designed to remove duplicates from an array based on a specified property.

**Native JavaScript feature explanation**

The custom implementation of `uniqBy` in Native JavaScript uses standard JavaScript features, such as:

1. **Sorting**: The `sort()` method is used to sort the array by the specified property.
2. **Iteration**: A loop is used to iterate over the sorted array and extract unique elements.

**Other considerations**

* The benchmark results show that the Native JavaScript implementation outperforms both Lodash and the custom JavaScript implementation. This suggests that, in this specific case, a native implementation can be more efficient than using an external library or implementing it manually.
* The use of `len = arr.length` in the Native JavaScript implementation is interesting. This is because array lengths are not always accurately represented by the `length` property in older browsers. Using `arr.length` ensures that the loop iterates over the correct number of elements, even in cases where `length` might be out of date.

**Alternatives**

The benchmark only shows three alternatives: Lodash, Native JavaScript, and an unknown alternative (not implemented). There may be other approaches or libraries that could be used to implement `uniqBy`, such as:

1. **Underscore.js**: Another popular JavaScript utility library that provides a `uniq` function.
2. **Array.prototype.filter()`: Using the `filter()` method to remove duplicates from an array can also be effective, although it might not be as efficient as sorting and iterating over the array.

Overall, this benchmark highlights the importance of considering performance and optimization when implementing algorithms or using external libraries in JavaScript applications.

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36

Browser/OS: Chrome 130 on Linux

View result in a separate tab

Test name	Executions per second
lodash	2644508.8 Ops/sec
javascript	2824100.5 Ops/sec
native	3010491.2 Ops/sec

Related benchmarks:

uniqBy performance lodash vs native (version: 0)

lodash vs javascript

Comparing performance of: lodash vs javascript vs native

Created: 2 years ago by: Guest

Jump to the latest result

lodash

javascript

native

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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