Benchmark: Lodash Uniq vs Javascript [...new Set()] 2

Script Preparation code:

var firstEqual = [];
var secondEqual = [];
for (var i=0; i<=1000000; i++) {
  firstEqual.push(i);
  secondEqual.push(i);
}
var arrayToDedup = [...firstEqual, ...secondEqual];

Tests:

Lodash Uniq
_.uniq(arrayToDedup);
Javascript Set
[...new Set(arrayToDedup)]

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash Uniq
Javascript Set

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what's being tested, compared, and considered.

**Benchmark Definition**

The benchmark is testing two approaches for removing duplicates from an array: Lodash's `uniq` function and the built-in JavaScript `Set` data structure.

**Script Preparation Code**

The script preparation code creates two large arrays, `firstEqual` and `secondEqual`, by pushing 1 million elements each. The combined array is then split into two parts using the spread operator (`[...firstEqual, ...secondEqual]`). This ensures that both approaches are given a large dataset to work with.

**Html Preparation Code**

There is no HTML preparation code provided in this benchmark definition.

**Individual Test Cases**

The benchmark consists of two individual test cases:

1. `Lodash Uniq`: Tests the performance of Lodash's `uniq` function on the prepared array.
2. `Javascript Set`: Tests the performance of using a built-in JavaScript `Set` data structure to remove duplicates from the same prepared array.

**Library: Lodash**

In this benchmark, Lodash is used as a utility library for its `uniq` function, which removes duplicate elements from an array while preserving order.

**Special JS Feature: None**

There are no special JavaScript features or syntax being tested in this benchmark. The focus is on comparing two standard approaches to removing duplicates from an array.

**Pros and Cons of Approaches**

Here's a brief summary of the pros and cons of each approach:

1. **Lodash Uniq**:
	* Pros: Handles edge cases (e.g., duplicate elements with the same value) and preserves order.
	* Cons: Adds overhead due to function call and potentially slow for very large datasets.
2. **Javascript Set**:
	* Pros: Fast, efficient, and simple implementation.
	* Cons: Does not preserve order, and may throw errors if used incorrectly.

**Other Alternatives**

If you were to create a benchmark like this from scratch, other alternatives could be:

1. Using a library like `lodash`'s `uniqBy` or `uniqueValue`
2. Implementing a custom solution using JavaScript's built-in `Array.prototype.filter()` method
3. Comparing with other data structures like `Map` or `Set`, but with the added complexity of preserving order.

Keep in mind that the choice of approach depends on the specific requirements and constraints of your project.

**Benchmark Result Interpretation**

The latest benchmark result shows:

* The `Javascript Set` approach performed faster (8.716 executions per second) compared to Lodash's `uniq` function (7.433 executions per second).
* This suggests that for this particular use case, the built-in JavaScript `Set` data structure might be a more efficient choice.

However, it's essential to note that benchmark results can depend on various factors like browser version, operating system, and hardware configuration.

Related benchmarks:

Lodash Uniq vs Javascript [...new Set()] 2 (version: 0)

Comparing performance of: Lodash Uniq vs Javascript Set

Created: 4 years ago by: Guest

Jump to the latest result

Lodash Uniq

Javascript Set

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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