Benchmark: Set vs Filter vs forEach vs forLoop vs filterWithSet vs map 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)
filterWithSet
const set = {} const b = array.filter((val) => { if(!set.hasOwnProperty(val)) { set[val] = true return true } return false })

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
filterWithSet

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; rv:123.0) Gecko/20100101 Firefox/123.0

Browser/OS: Firefox 123 on Windows

View result in a separate tab

Basic forEach

13.8M/s

filterWithSet

1.6M/s

for loop

1.4M/s

Filter

1.0M/s

Array from set

919K/s

Set spread

908K/s

View exact numbers

Test name	Executions per second
✓ Basic forEach	13,790,324 Ops/sec
filterWithSet	1,552,572 Ops/sec
for loop	1,399,112 Ops/sec
Filter	1,035,060 Ops/sec
Array from set	918,956 Ops/sec
Set spread	908,120 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 provided benchmark and explain what's being tested, compared, and their pros and cons.

**Benchmark Overview**

The benchmark tests the performance of different approaches to remove duplicates from an array:

1. `Set` (using `Array.from(new Set(array))`)
2. `Filter` (using `array.filter((i,index) => array.indexOf(i)=== index)`)
3. `Basic forEach` (using a manual implementation with a hash table)
4. `for loop`
5. `filterWithSet` (using a filter function with a set)

**Options Comparison**

Here's a brief overview of each option:

### 1. `Set` (using `Array.from(new Set(array))`)

* This approach creates a new `Set` object from the array, which automatically removes duplicates.
* Pros:
	+ Simple and concise implementation.
	+ Fast performance due to set operations being optimized by the browser.
* Cons:
	+ Requires the use of modern JavaScript features (ECMAScript 2015+).
	+ May not be compatible with older browsers.

### 2. `Filter` (using `array.filter((i,index) => array.indexOf(i)=== index)`)

* This approach uses the `filter()` method to create a new array with only unique elements.
* Pros:
	+ Wide browser support, including older versions of Firefox.
	+ Easy to understand and implement.
* Cons:
	+ Can be slower than other approaches due to the overhead of the filter() method.

### 3. `Basic forEach` (using a manual implementation with a hash table)

* This approach uses a traditional `forEach()` loop with a hash table to keep track of unique elements.
* Pros:
	+ No dependencies on modern JavaScript features.
	+ Can be faster than other approaches due to the overhead of set operations being eliminated.
* Cons:
	+ More verbose and complex implementation compared to other options.

### 4. `for loop`

* This approach uses a traditional `for` loop to iterate over the array, skipping duplicates manually.
* Pros:
	+ Simple and easy to understand.
	+ Wide browser support.
* Cons:
	+ Can be slower than other approaches due to the overhead of manual duplicate detection.

### 5. `filterWithSet` (using a filter function with a set)

* This approach combines the benefits of `Filter` and `Basic forEach` by using a filter function with a set to keep track of unique elements.
* Pros:
	+ Faster performance than traditional `for` loop or `filter()` method due to set operations being used.
	+ Easy to understand and implement.
* Cons:
	+ Requires the use of modern JavaScript features (ECMAScript 2015+).
	+ May not be compatible with older browsers.

**Library: None**

None of the benchmark options rely on external libraries. The `Set` object is a built-in JavaScript feature, while the other options use only native JavaScript methods and loops.

**Special JS Feature/Syntax: Set**

The `Set` object uses modern JavaScript features (ECMAScript 2015+) to create a set data structure. This allows for fast and efficient duplicate removal. Older browsers may not support this feature, but it's commonly used in modern web development.

**Other Alternatives**

Some alternative approaches that could be considered include:

* Using `Array.from` with an object as the second argument (e.g., `Array.from(array, x => {})`)
* Using a library like Lodash or Underscore.js to implement duplicate removal
* Implementing a custom hash table data structure

However, these alternatives may introduce additional dependencies and complexity, making them less suitable for this specific benchmark.

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

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

Created: 2 years ago by: Guest

Go to the latest result

Set spread

Array from set

Filter

Basic forEach

for loop

filterWithSet

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

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

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

Created: 2 years ago by: Guest

Go to the latest result

Set spread

Array from set

Filter

Basic forEach

for loop

filterWithSet

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

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