Benchmark: Unique values (large list)

Script Preparation code:

var array = [];

for (var i = 0; i < 1000; i++) {
  array.push(Math.random() * 1000);
}

Tests:

Set
[...new Set(array)];
Filter
array.filter((item, index) => array.indexOf(item) === index);
Reduce
array.reduce((unique, item) => unique.includes(item) ? unique : [...unique, item], []);
Lodash
_.uniq(array)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Set
Filter
Reduce
Lodash

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 years ago)

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

Browser/OS: Chrome 103 on Windows

View result in a separate tab

Test name	Executions per second
Set	22496.8 Ops/sec
Filter	2426.5 Ops/sec
Reduce	548.8 Ops/sec
Lodash	18631.1 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down what's being tested in this benchmark.

**What is being tested?**

The benchmark tests the performance of different algorithms for removing duplicates from an array:

1. `Set`: creates a new Set object from the input array, which automatically removes duplicates.
2. `Filter`: uses the `filter()` method to create a new array with only unique elements.
3. `Reduce`: uses the `reduce()` method to accumulate a set of unique elements.
4. `_uniq` (from Lodash library): uses the `_uniq` function from the Lodash library, which is similar to the `Set` and `Filter` approaches.

**Options compared**

The benchmark compares the performance of these four approaches:

* `Set`: creates a new Set object from the input array.
* `Filter`: uses the `filter()` method with a callback function that checks for duplicates.
* `Reduce`: uses the `reduce()` method with an accumulator that keeps track of unique elements.
* `_uniq` (Lodash): uses the `_uniq` function from the Lodash library, which is similar to the `Set` and `Filter` approaches.

**Pros and Cons**

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

1. **Set**: Pros:
	* Fast and efficient, as Sets are optimized for performance.
	* Easy to use and understand.
	Con: May require extra memory allocation for the Set object.
2. **Filter**: Pros:
	* Simple and intuitive implementation.
	* Works with most array methods.
Cons: May have higher overhead due to the filter method's complexity.
3. **Reduce**: Pros:
	* Can be used in conjunction with other reduce functions.
	* Allows for more control over the reduction process.
Cons: Requires an accumulator function, which can add complexity.
4. `_uniq` (Lodash): Pros:
	* Part of the popular Lodash library, so users are likely familiar with it.
	* Easy to use and understand.
Con: Requires an external dependency on Lodash.

**Library and special JS features**

The benchmark uses the Lodash library for its `_uniq` function. Lodash is a utility library that provides a collection of helper functions, including `uniq`.

No other special JavaScript features or syntax are used in this benchmark.

**Alternatives**

Some alternatives to these approaches could be:

* Using an `Array` with `forEach()` and checking for duplicates manually.
* Using a different data structure, such as a `Map`, to store unique elements.
* Implementing a custom solution using recursive functions or bitwise operations.

However, these alternatives are less efficient and more prone to errors compared to the tested approaches.

Related benchmarks:

Unique values (large list) (version: 0)

Comparing performance of: Set vs Filter vs Reduce vs Lodash

Created: 3 years ago by: Guest

Jump to the latest result

Set

Filter

Reduce

Lodash

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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