Benchmark: Set vs array add

Script Preparation code:

var data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
var bigArray = [];
var bigSet = new Set();

Tests:

Set (small)
var smallSet = new Set(); for (const item of data) { smallSet.add(item); }
Array (small)
var smallArray = []; for (const item of data) { smallArray.push(item) }
Set (big)
for (const item of data) { bigSet.add(item); }
Array (big)
for (const item of data) { bigArray.push(item) }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Set (small)
Array (small)
Set (big)
Array (big)

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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 considered.

**Benchmark Definition:**
The benchmark is designed to measure the performance of two data structures: sets and arrays. The script preparation code creates an array `data` with 10 elements and initializes both a small set `bigSet` and a large set `smallSet`. It also creates two small arrays `smallArray` and a large array `bigArray`.

**Test Cases:**
There are four test cases:

1. **Set (small)**: Creates a small set `smallSet` and adds all elements from the `data` array to it using a for...of loop.
2. **Array (small)**: Creates a small array `smallArray` and adds all elements from the `data` array to it using a push method.
3. **Set (big)**: Adds all elements from the `data` array to the large set `bigSet` without creating any intermediate data structure, directly using the for...of loop.
4. **Array (big)**: Adds all elements from the `data` array to the large array `bigArray` using a push method.

**Options Compared:**

* **Small Set vs Small Array**: Both small sets and arrays have similar performance characteristics in this test case, with the set being slightly faster due to its hash table-based implementation.
	+ Pros of Sets:
		- Hash table-based data structure provides fast lookups and insertions.
		- No need for indexing or bounds checking.
	+ Cons of Sets:
		- Typically slower than arrays for simple iteration.
		- May have higher memory overhead due to the hash function.
* **Large Set vs Large Array**: The set is significantly faster than the array in this case, likely due to its optimized implementation and lack of indexing or bounds checking.
	+ Pros of Sets:
		- Much faster iteration and insertion times compared to arrays.
		- Optimized for common use cases like membership testing.
	+ Cons of Sets:
		- May have higher memory overhead due to the hash function.
		- Limited control over elements' order.

**Other Considerations:**

* **Library:** The benchmark uses JavaScript's built-in `Set` and array data structures, which are implemented in C++ under the hood. No external libraries or frameworks are used.
* **Special JS Feature/Syntax:** None mentioned.

**Alternatives:**
If you're interested in exploring alternative data structures for performance-critical applications, consider:

* **Linked Hash Sets**: Data structures that combine the benefits of sets and linked lists.
* **Array-based Data Structures**: Implementations like array queues or array stacks that offer faster iteration times at the cost of increased memory usage.

Keep in mind that these alternatives are typically used for specific use cases or performance-critical applications, and their implementation can be more complex than the built-in JavaScript data structures.

Related benchmarks:

Set vs array add (version: 0)

Comparing performance of: Set (small) vs Array (small) vs Set (big) vs Array (big)

Created: 4 years ago by: Guest

Jump to the latest result

Set (small)

Array (small)

Set (big)

Array (big)

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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