Benchmark: Set vs Filter vs includes+push 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)
filter 2
const b2 = array.filter((i,index, arr) => arr.indexOf(i)=== index)
includes
var ar2 = []; array.forEach(i => { if (!ar2.includes(i)) { ar2.push(i); } });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Set spread
Array from set
Filter
filter 2
includes

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 116 on Windows

View result in a separate tab

Test name	Executions per second
Set spread	1386231.6 Ops/sec
Array from set	1236415.1 Ops/sec
Filter	361293.4 Ops/sec
filter 2	1420829.8 Ops/sec
includes	1541594.8 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

The provided JSON represents a benchmark test that compares the performance of different approaches to achieve uniqueness in an array. The goal is to determine which method is the fastest.

**Options being compared:**

1. `Set spread` (`const f = [... new Set(array)]`)
2. `Array from set` (`const s = new Set(array)\r\nconst l = Array.from(s)`)
3. `Filter` (`const b = array.filter((i,index) => array.indexOf(i)=== index)`)
4. `Includes with push` (`var ar2 = [];\r\narray.forEach(i => {\r\n\tif (!ar2.includes(i)) {\r\n      ar2.push(i);\r\n    }\r\n});`)

**Pros and Cons of each approach:**

1. **Set spread**: This method creates a new array by spreading the elements of a set. It's concise and efficient, as sets automatically eliminate duplicates.
	* Pros: Fast, simple, and readable.
	* Cons: May not be suitable for large datasets, as it creates a new array in memory.
2. **Array from set**: This method creates an array from a set by converting the set to an array using `Array.from()`.
	* Pros: Flexible, as you can use different set-to-array conversion methods (e.g., `map()` or `forEach()`).
	* Cons: May be slower than the set spread approach due to additional overhead.
3. **Filter**: This method uses the `filter()` function to create a new array with only unique elements by checking each element's index against its existence in the original array.
	* Pros: Flexible, as you can use different filtering criteria (e.g., using a predicate function).
	* Cons: May be slower than the set spread approach due to additional overhead and potential memory issues.
4. **Includes with push**: This method uses a traditional loop to iterate through the array and push unique elements into a new array (`ar2`).
	* Pros: Simple, easy to understand, and suitable for large datasets.
	* Cons: May be slower than other approaches due to the overhead of looping and pushing.

**Library and syntax used in test cases:**

1. `Set`: A built-in JavaScript object that automatically eliminates duplicates. Used in `Set spread` and `Array from set`.
2. No libraries or special features are used in these test cases.

**Other considerations:**

* When working with large datasets, memory usage and performance become critical factors.
* Choosing the right approach depends on the specific requirements of your use case (e.g., size, performance, readability).
* It's essential to consider that each approach has its own trade-offs and may not be suitable for every scenario.

**Alternatives:**

Other approaches to achieve uniqueness in an array include:

1. Using a `Map` instead of a `Set`. While `Map` is similar to `Set`, it uses keys instead of values, which can affect performance.
2. Utilizing the `uniqueValue` function from the Lodash library (if using that library).
3. Implementing a custom algorithm using bitwise operations or other optimizations.

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

Related benchmarks:

Set vs Filter vs includes+push for unique (version: 0)

Comparing performance of: Set spread vs Array from set vs Filter vs filter 2 vs includes

Created: 3 years ago by: Guest

Jump to the latest result

Set spread

Array from set

Filter

filter 2

includes

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):