Toggle navigation
MeasureThat
.net
Create a benchmark
Tools
Feedback
Feature Requests
FAQ
Register
Log In
lodash uniqWith vs filter
(version: 0)
Benchmark.js
Comparing performance of:
use lodash vs filter
Created:
4 years ago
by:
Guest
Go to the latest result
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>
Run tests (2)
Previous results
Fork
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
Embed
Embed Benchmark Result
<iframe src="https://measurethat.net/Embed?id=602092" width="100%" height="500px"></iframe>
filter
27.5M/s
use lodash
25.8M/s
View exact numbers
Test name
Executions per second
✓
filter
27,514,898 Ops/sec
use lodash
25,794,586 Ops/sec
Autogenerated LLM Summary
(model
llama3.2:3b
, generated one year ago):
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 uniq vs native uniq
uniqBy performance lodash vs native
Comments
Confirm delete:
Do you really want to delete benchmark?