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

Autogenerated LLM Summary (model llama3.2:3b, generated one month 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.

Latest run results:

Run details: (Test run date: 9 months 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

Test name	Executions per second
Set spread	908120.3 Ops/sec
Array from set	918955.9 Ops/sec
Filter	1035059.9 Ops/sec
Basic forEach	13790324.0 Ops/sec
for loop	1399112.1 Ops/sec
filterWithSet	1552571.5 Ops/sec

Related benchmarks:

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: 9 months ago by: Guest

Jump to the latest result

Set spread

Array from set

Filter

Basic forEach

for loop

filterWithSet

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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