Benchmark: lodash uniqWith vs filter

HTML Preparation code:


<script src='https://cdn.jsdelivr.net/npm/lodash@4.17.10/lodash.min.js'></script>

Tests:

use lodash
const arr = [{userInfo: { id: 1 } }, {userInfo: { id: 1 } }, {userInfo: { id: 2 } }, {userInfo: { id: 1 } }, {userInfo: { id: 4 } }, {userInfo: { id: 3 } }, {userInfo: { id: 4 } }, {userInfo: { id: 5 } }] return _.uniqWith(arr, (a, b) => a.userInfo.id === b.userInfo.id)
filter
const arr = [{userInfo: { id: 1 } }, {userInfo: { id: 1 } }, {userInfo: { id: 2 } }, {userInfo: { id: 1 } }, {userInfo: { id: 4 } }, {userInfo: { id: 3 } }, {userInfo: { id: 4 } }, {userInfo: { id: 5 } }] return arr.filter((client, index, self) => index === self.findIndex(c => c.userInfo.id === client.userInfo.id))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
use lodash
filter

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/135.0.0.0 Safari/537.36

Browser/OS: Chrome 135 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
use lodash	25794586.0 Ops/sec
filter	27514898.0 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.

**Benchmark Overview**

The provided benchmark compares two approaches to removing duplicate elements from an array: using `lodash uniqWith` and using the built-in `filter()` method. The goal is to determine which approach is faster, especially in cases where the duplicate check requires access to both elements of the pair (e.g., when comparing objects).

**Options Compared**

The benchmark tests two options:

1. **Lodash `uniqWith`**: This function takes a callback function that determines whether two elements are equal. In this case, the callback checks if the `id` property of each object is equal.
2. **Built-in `filter()` method**: This method uses the `index === self.findIndex(c => c.userInfo.id === client.userInfo.id)` condition to determine which elements to keep.

**Pros and Cons**

**Lodash `uniqWith`:**

Pros:

* Easy to use and understand
* Provides a clear and concise way to define equality checks

Cons:

* Requires an external library (lodash) to be included in the test environment
* May have performance overhead due to the need to load the library

**Built-in `filter()` method:**

Pros:

* Built-in function, no extra dependencies required
* Can take advantage of compiler optimizations and caching

Cons:

* May require more complex logic to define equality checks
* Potential for less readable code

**Other Considerations**

When choosing between these two approaches, consider the trade-off between readability and performance. If readability is important, `uniqWith` might be a better choice. However, if performance is critical, using the built-in `filter()` method might provide a slight advantage.

**Library Used (Lodash)**

Lodash is a popular JavaScript utility library that provides various functions for tasks like array manipulation, string manipulation, and more. In this case, `uniqWith` is used to remove duplicate elements from an array based on a custom equality check. The `filter()` method, on the other hand, uses its own internal equality check mechanism.

**Special JS Feature/ Syntax**

There are no special JavaScript features or syntaxes used in this benchmark that would require specific handling or explanation.

**Alternative Approaches**

Other approaches to removing duplicate elements from an array might include:

1. Using `Set` data structure: Create a Set from the array and then iterate over it to get unique elements.
2. Using `reduce()`: Use the `reduce()` method to accumulate unique elements in an array.
3. Implementing custom equality check using `Array.prototype.map()` or `Array.prototype.forEach()`.
4. Using a third-party library like `array-unique` (which is not used in this benchmark).

Keep in mind that each approach has its own trade-offs and performance characteristics, so it's essential to consider the specific requirements of your use case when choosing an approach.

Related benchmarks:

lodash uniqWith vs filter (version: 0)

Comparing performance of: use lodash vs filter

Created: 4 years ago by: Guest

Jump to the latest result

use lodash

filter

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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