Benchmark: Set vs Array for unique list (convert set to array) 2

Script Preparation code:

var a = Array(1000).fill(null).map((a, b) => b);

Tests:

Unique Array
var b = []; a.forEach(x => { if (a.indexOf(x) < 0) a.push(x); }); a.map(x => x);
Set
var c = new Set(); a.forEach(x => c.add(x)); var b = Array.from(a); b.map(x => x);
Arr 2
var b = []; a.forEach(x => { if (a.indexOf(x) === -1) a.push(x); }); a.map(x => x);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Unique Array
Set
Arr 2

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 JSON and explain what is being tested in each benchmark.

**Benchmark Definition**

The first part of the JSON, `{"Name": "Set vs Array for unique list (convert set to array) 2", ...}` defines a benchmark with the following characteristics:

* The test compares two approaches: using an array (`a`) and using a set (`c`).
* The test is about finding unique elements in the array by converting it to a set, and then back to an array.
* The test has a description of "Set vs Array for unique list (convert set to array) 2", but this description is not used anywhere in the benchmark.

**Script Preparation Code**

The script preparation code `var a = Array(1000).fill(null).map((a, b) => b);` creates an array `a` with 1000 elements, all filled with null values. This array will be used to test the performance of finding unique elements in both arrays and sets.

**Html Preparation Code**

The html preparation code is empty (`"Html Preparation Code": null`), which means that no HTML page is being generated for this benchmark.

**Individual Test Cases**

There are three individual test cases:

1. **Unique Array**

This test case uses the following script:
```javascript
a.forEach(x => {
  if (a.indexOf(x) < 0) a.push(x);
});
a.map(x => x);
```
This code finds unique elements in the array `a` by iterating through it and checking if each element is already present using `indexOf()`. If not, it adds the element to the end of the array. Finally, it maps over the original array to return a new array with the same elements.

2. **Set**

This test case uses the following script:
```javascript
var c = new Set();
a.forEach(x => c.add(x));
var b = Array.from(a);
b.map(x => x);
```
This code creates an empty set `c` and adds all elements from array `a` to it using `add()`. Then, it converts the set back to an array using `Array.from()` and maps over the original array to return a new array with the same elements.

3. **Arr 2**

This test case uses the following script:
```javascript
a.forEach(x => {
  if (a.indexOf(x) === -1) a.push(x);
});
a.map(x => x);
```
This code is similar to the first test case, but it checks for `indexOf()` returning `-1` instead of `< 0`, which is equivalent to checking if an element is not present in the array.

**Pros and Cons**

Here are some pros and cons of each approach:

* **Unique Array**
	+ Pros: straightforward implementation, easy to understand.
	+ Cons: uses `indexOf()`, which can be slower than using a set or array with unique values.
* **Set**
	+ Pros: uses a set, which is optimized for fast lookups. This makes it faster than the `uniqueArray` approach.
	+ Cons: requires creating an empty set and converting back to an array, which adds overhead.
* **Arr 2**
	+ Pros: similar to the first test case but with less conditions.
	+ Cons: still uses `indexOf()`, making it slower than using a set or array with unique values.

**Other Considerations**

The benchmark is running on Firefox 113 on Ubuntu Linux, which may have some platform-specific optimizations that affect performance. Additionally, the script preparation code creates an array of 1000 elements, which may be a small number for some tests and too large for others.

**Library**

In this case, there is no specific JavaScript library being used beyond the built-in `Array` and `Set` data structures. However, it's worth noting that the `Set` implementation in older browsers or Node.js versions might have different performance characteristics compared to modern implementations.

**Special JS Feature/Syntax**

There are no special JS features or syntax being tested in this benchmark. The code uses standard JavaScript features like `Array`, `Set`, `forEach`, and `map`.

Latest run results:

Run details: (Test run date: 11 months ago)

User agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/113.0

Browser/OS: Firefox 113 on Ubuntu

View result in a separate tab

Test name	Executions per second
Unique Array	2265.8 Ops/sec
Set	10675.7 Ops/sec
Arr 2	2274.7 Ops/sec

Related benchmarks:

Set vs Array for unique list (convert set to array) 2 (version: 0)

Comparing performance of: Unique Array vs Set vs Arr 2

Created: 11 months ago by: Guest

Jump to the latest result

Unique Array

Set

Arr 2

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