Benchmark: lodash UniqueWith vs custom filter 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] && trackObj[item.a].includes(item.b)) { return false; } trackObj[item.a] = [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.

The provided JSON represents a JavaScript benchmark test case for measuring the performance of two approaches: using Lodash's `uniqWith` function and implementing a custom filtering approach to remove duplicates from an array.

**What is being tested?**

The benchmark tests how efficiently these two approaches can eliminate duplicate elements from an array. The input data consists of 7000 objects, each with properties 'a' and 'b'.

**Options compared:**

1. **Lodash's `uniqWith` function**: This is a utility function that removes duplicates from an array based on a provided comparison function. In this case, the comparison function used is `_.isEqual`.
2. **Custom filtering approach**: This involves using a filter method to remove duplicate elements from the array. The custom implementation uses an object to keep track of unique items.

**Pros and Cons:**

1. **Lodash's `uniqWith` function**:
	* Pros:
		+ Lightweight and efficient, as it only requires one pass through the data.
		+ Robust, with support for various comparison functions.
	* Cons:
		+ Additional dependency on Lodash, which might not be present in all environments.
		+ May have a slight overhead due to the function call and object lookup.
2. **Custom filtering approach**:
	* Pros:
		+ No additional dependencies required.
		+ Can be optimized for performance by using a single pass through the data.
	* Cons:
		+ Requires manual implementation of the filtering logic, which can be error-prone and time-consuming.
		+ May have higher overhead due to object creation and lookup.

**Library: Lodash**

Lodash is a popular JavaScript utility library that provides a collection of functional programming helpers. In this benchmark, `uniqWith` is used as a comparison function to remove duplicates from the array. The purpose of `uniqWith` is to provide a way to compare two values without considering their exact equality, which can be useful in scenarios where exact equality is not sufficient.

**Special JS feature or syntax: None**

There are no special JavaScript features or syntaxes used in this benchmark.

**Other alternatives**

If you wanted to implement the custom filtering approach with different optimizations, some possible alternatives could include:

1. Using a `Set` data structure instead of an object to keep track of unique items.
2. Caching the filtered array result to avoid re-computing it on each execution.
3. Using a more efficient algorithm for removing duplicates, such as using a hash table or a trie.

However, these alternatives may require additional considerations regarding performance, memory usage, and code readability.

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 110 on Linux

View result in a separate tab

Test name	Executions per second
_.uniqWith	497877.0 Ops/sec
filter	666752.4 Ops/sec

Related benchmarks:

lodash UniqueWith vs custom filter 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):