Benchmark: lodash UniqueWith vs custom filter with isEqual for duplicates

Script Preparation code:

var myArray = Array(7000).fill({a:1, b:2});

Tests:

_.uniqWith
myArray = _.uniqWith(myArray, _.isEqual);
filter
const trackObj = {}; myArray = myArray.filter(item => { if (trackObj[item.a]) { const foundDuplicateValue = (trackObj[item.a]).some((val) => { return _.isEqual(val, item.b); }); // If no duplicate value found, do nothing in this if block. // If duplicate value found, return false. This will filter out this datum. if (foundDuplicateValue) return false; } if (!trackObj[item.a]) { trackObj[item.a] = [item.b]; } else { trackObj[item.a].push(item.b); } return true; })

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
_.uniqWith
filter

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Measuring JavaScript performance is a crucial aspect of software development, as it can significantly impact the user experience and application responsiveness.

The provided benchmark definition in JSON format represents two test cases:

1.  **_.uniqWith**:

*   The script preparation code initializes an array `myArray` with 7000 elements, each containing two properties: `a` and `b`.
    *   This code is used to measure the performance of Lodash's `_.uniqWith` function.
    *   The purpose of this test is to evaluate how efficiently Lodash can identify unique combinations of `a` and `b` in the array, using a custom filter with `_.isEqual` as the equality check function.

2.  **Custom Filter**:

*   This script preparation code initializes an array `myArray` with 7000 elements, each containing two properties: `a` and `b`.
    *   The test measures the performance of a custom filter written in JavaScript, which aims to achieve similar uniqueness identification as Lodash's `_.uniqWith` but without using external libraries.
    *   The custom filter uses an object `trackObj` to keep track of seen values for each item in the array. It iterates over the array and checks if a value is already present in `trackObj`. If it is, the function returns `false`, filtering out that duplicate value. Otherwise, it adds the value to the appropriate list in `trackObj`.

Now, let's discuss some pros and cons of these approaches:

### _.uniqWith vs Custom Filter

*   **Pros of Lodash's _.uniqWith**:
    *   More concise code: Lodash provides a well-optimized implementation with built-in handling for edge cases.
    *   Familiar API: Lodash is widely used, making it easy to find resources and documentation.

*   **Cons of Lodash's _.uniqWith**:
    *   External dependency: The benchmark relies on the presence of Lodash, which may not be feasible in all environments or projects.
    *   Additional overhead: Although optimized, Lodash introduces an additional layer for performance that might negate any potential benefits.

*   **Pros of Custom Filter**:
    *   No external dependencies: This approach uses only built-in JavaScript features and libraries (e.g., `Array.prototype.filter`, `Object`), reducing the risk of added overhead.
    *   Fine-grained control: By implementing custom logic, you have complete visibility into every step of the process.

*   **Cons of Custom Filter**:
    *   More complex code: The implementation requires manual handling of edge cases and duplicates, which can increase code complexity.
    *   Potential for performance issues: Without optimized built-in functions like `_.uniqWith`, the custom filter may not be as efficient in practice.

### Other Considerations

*   **Performance overhead**: When comparing performance benchmarks, it's essential to consider any additional overhead introduced by external libraries or frameworks. This can include memory allocation, garbage collection, and other system resources.
*   **Implementation complexity**: More complex implementations might lead to code bloat or maintainability issues, which can outweigh any potential benefits of custom optimization.

Now that we've discussed the test cases in detail, let's take a look at some alternatives for benchmarking JavaScript performance:

1.  **Node.js built-in functions**: Instead of using external libraries like Lodash, you could leverage Node.js built-in functions (e.g., `Array.prototype.filter`, `Object.keys()`) for your benchmarks.
2.  **Benchmarking frameworks**: There are various benchmarking frameworks available for Node.js, such as BenchmarkJS or V8-benchmark, which provide a standardized way to measure performance and help ensure consistency across different tests.
3.  **ES modules (ESM) optimization techniques**: If you're developing an ESM project, consider optimizing your code using native module features like `for...of` loops, `const` declarations, or `Object.entries()` methods, which can improve performance.

When choosing the best approach for your specific use case, consider factors such as:

*   **Complexity of implementation**: How complex is the custom filter or optimization technique?
*   **Performance requirements**: What kind of performance are you trying to achieve in your benchmark?
*   **Library and framework dependencies**: Are there any external dependencies that need to be considered?

Ultimately, understanding the pros and cons of each approach will help you make informed decisions about how to optimize your JavaScript code for better performance.

Latest run results:

Run details: (Test run date: 3 months ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36

Browser/OS: Chrome 126 on Windows

View result in a separate tab

Test name	Executions per second
_.uniqWith	5679230.0 Ops/sec
filter	7101818.0 Ops/sec

Related benchmarks:

lodash UniqueWith vs custom filter with isEqual for duplicates (version: 0)

Comparing performance of: _.uniqWith vs filter

Created: one year ago by: Guest

Jump to the latest result

_.uniqWith

filter

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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