Benchmark: Set vs Filter vs forEach vs forLoop for unique

Script Preparation code:

var array = Array.from({length: 40}, () => Math.floor(Math.random() * 140));

Tests:

Set spread
const f = [... new Set(array)]
Array from set
const s = new Set(array) const l = Array.from(s)
Filter
const b = array.filter((i,index) => array.indexOf(i)=== index)
Basic forEach
const set = {} array.forEach(val => set.hasOwnProperty(val) ? set[val] = true : '') const b = Object.keys(set)
for loop
const set = {} for(var i = 0, l = array.length; i < l; i++){ if(!set.hasOwnProperty(array[i])) set[array[i]] = true } const b = Object.keys(set)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Set spread
Array from set
Filter
Basic forEach
for loop

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36

Browser/OS: Chrome 120 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Set spread	1292919.1 Ops/sec
Array from set	1220223.6 Ops/sec
Filter	528408.6 Ops/sec
Basic forEach	2987592.0 Ops/sec
for loop	304942.2 Ops/sec

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 its test cases.

**What is being tested?**

The provided JSON represents a JavaScript microbenchmark that compares four different approaches to remove duplicate elements from an array:

1. `Set spread` (const f = [... new Set(array)])
2. `Array from set` (new Set(array).map(x => x))
3. `Filter` (array.filter((i,index) => array.indexOf(i)=== index))
4. `Basic forEach` (forEach loop with a custom object to track unique elements)
5. `for loop` (a traditional for loop with an if statement to check for uniqueness)

These approaches are compared in terms of execution time.

**Options comparison**

The test cases compare different methods to achieve the same result:

* Removing duplicates from an array
* The methods differ in their approach:
	+ Set spread and Array from set use a built-in Set object to remove duplicates, which is more efficient.
	+ Filter uses a custom condition to check if each element's index is equal to its value in the array, which can lead to performance issues with large arrays.
	+ Basic forEach uses a manual approach with an object to track unique elements, which can be less efficient than using a Set or Filter.
	+ For loop uses a traditional for loop with an if statement to check for uniqueness, which can also be less efficient.

**Pros and Cons**

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

* **Set spread**:
	+ Pros: Fast, efficient, and concise.
	+ Cons: May not work as expected if the array contains non-unique elements with the same value (only the first occurrence is kept).
* **Array from set**:
	+ Pros: Also fast and efficient, with a similar performance to Set spread.
	+ Cons: May require additional processing to handle arrays with duplicate values.
* **Filter**:
	+ Pros: Simple and easy to understand.
	+ Cons: Can be slow for large arrays due to the repeated array indexing and comparison operations.
* **Basic forEach**:
	+ Pros: Customizable and can handle more complex uniqueness checks.
	+ Cons: Less efficient than Set spread or Array from set, with a higher constant factor.

**Libraries and special features**

The test cases use:

* None of the test cases explicitly use any external libraries. However, it's worth noting that the `Set` object is a built-in JavaScript feature, and its usage is not dependent on any external library.
* The `for...of` loop syntax (not shown in the provided code) could be used to simplify the for loop implementation. However, this feature was introduced in ECMAScript 2017 and may not be supported by older browsers or environments.

**Other alternatives**

If you're looking for alternative approaches to remove duplicates from an array, some other options include:

* Using a `Map` object instead of a `Set`, which can provide more flexibility with duplicate values.
* Using the `some()` method in combination with `indexOf()`.
* Using a custom sorting or shuffling algorithm to rearrange elements and then selecting unique ones.

Keep in mind that each approach has its trade-offs, and the best solution will depend on your specific use case, performance requirements, and personal preference.

Related benchmarks:

Set vs Filter vs forEach vs forLoop for unique (version: 0)

Comparing performance of: Set spread vs Array from set vs Filter vs Basic forEach vs for loop

Created: 2 years ago by: Guest

Jump to the latest result

Set spread

Array from set

Filter

Basic forEach

for loop

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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