Benchmark: set.add vs array.push Fabien

Script Preparation code:

var array = [];
var set = new Set();
var map = new Map();

var existingItem1 = {};
var existingItem2 = {};
var existingItem3 = {};
var newItem1 = {};
var newItem2 = {};
var newItem3 = {};

for (let i = 0, item; i < 100; i++) {
  item = {index: i};
  array.push(item);
  set.add(item);
  map.set(item, 0);
}

array.push(existingItem1, existingItem2, existingItem3);
set.add(existingItem1); set.add(existingItem2); set.add(existingItem3);
map.set(existingItem1, 0); map.set(existingItem2, 0); map.set(existingItem3, 0);

Tests:

conditional array.push
array.push(existingItem1); array.push(newItem1); array.push(existingItem2); array.push(newItem2); array.push(existingItem3); array.push(newItem3);
set.add
set.add(existingItem1); set.add(newItem1); set.add(existingItem2); set.add(newItem2); set.add(existingItem3); set.add(newItem3);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
conditional array.push
set.add

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

**Benchmark Definition JSON**

The benchmark measures the performance of adding elements to an array using two different approaches: `array.push` with conditional statements, and `set.add`.

The script preparation code creates:

* An empty array `array`
* A new Set object `set`
* Three existing items `existingItem1`, `existingItem2`, and `existingItem3`, as well as three new items `newItem1`, `newItem2`, and `newItem3`.
* The script then populates the array with 100 elements, adding each element using either `array.push` or `set.add`. Additionally, it adds three elements to the array without conditionally selecting them.

The purpose of this benchmark is to compare the performance of these two approaches: adding elements directly to an array using `array.push`, and using a data structure like a Set to track unique elements. We'll discuss the pros and cons of each approach in the next section.

**Options Compared**

1. **`array.push` with conditional statements**:
	* Pros:
		+ Simple and straightforward implementation.
		+ Can be easily integrated into existing codebases.
	* Cons:
		+ May lead to performance issues if the array grows too large, as it requires shifting all elements after adding a new one.
2. **`set.add`**:
	* Pros:
		+ Efficiently handles adding unique elements, especially when dealing with large datasets.
		+ Reduces memory usage by avoiding unnecessary copies of data.
	* Cons:
		+ May require additional setup and understanding of Set-like data structures.

**Other Considerations**

In addition to the `array.push` vs `set.add` comparison, this benchmark also touches on:

1. **Using existing items**: The benchmark adds three existing elements (`existingItem1`, `existingItem2`, `existingItem3`) directly to the array without conditionally selecting them. This helps to ensure that the results are not skewed by differences in element selection.
2. **Using new items**: Similarly, it also adds three new elements (`newItem1`, `newItem2`, `newItem3`) to demonstrate how these elements perform when added using `array.push`.

**Library and Special JS Features**

This benchmark does not explicitly use any libraries or special JavaScript features beyond the standard `Array` and `Set` data structures. However, it's worth noting that the use of Set-like data structures may require a basic understanding of their implementation.

**Alternative Approaches**

Other approaches to adding elements to an array might include:

1. **Using a queue**: Instead of using `array.push`, you could implement a queue data structure and add elements to it, which would be more efficient for large datasets.
2. **Using a heap**: If you need to prioritize elements based on their size or value, you could use a heap data structure to manage the array.
3. **Optimized insertion algorithms**: For very large datasets, specialized algorithms like insertion sort or bucket sort might offer better performance than `array.push`.

Keep in mind that the choice of approach depends on your specific requirements and constraints.

**Benchmark Preparation Code**

Here's an explanation of the script preparation code:

```javascript
var array = []; // Initialize an empty array
var set = new Set(); // Create a new Set object
var map = new Map(); // Create a new Map object

// Define existing items and new items
var existingItem1 = {};
var existingItem2 = {};
var existingItem3 = {};

var newItem1 = {};
var newItem2 = {};
var newItem3 = {};

// Populate the array with 100 elements using both array.push and set.add
for (let i = 0, item; i < 100; i++) {
    item = { index: i };
    array.push(item); // Add to array using array.push
    set.add(item); // Add to Set using set.add
    map.set(item, 0); // Add to Map using setAdd (note: Map does not have an add method)
}

// Add existing items without conditionally selecting them
array.push(existingItem1);
array.push(newItem1);
array.push(existingItem2);
array.push(newItem2);
array.push(existingItem3);

// Add new items using array.push with conditional statements
array.push(function() {
    if (i % 2 === 0) {
        return existingItem1;
    } else {
        return newItem1;
    }
}());

set.add(existingItem1); // Add to Set without conditionally selecting
set.add(newItem1);
```

The `map.set` call is used here, but note that Maps in JavaScript do not have an `add` method. This line would typically be replaced with `map.set(item, 0)` or using another mechanism to add elements to the Map.

I hope this explanation helps you understand the benchmark and its context!

Latest run results:

Run details: (Test run date: 2 years ago)

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

Browser/OS: Chrome 96 on Windows

View result in a separate tab

Test name	Executions per second
conditional array.push	663958.1 Ops/sec
set.add	699804.7 Ops/sec

Related benchmarks:

set.add vs array.push Fabien (version: 0)

Comparing performance of: conditional array.push vs set.add

Created: 2 years ago by: Guest

Jump to the latest result

conditional array.push

set.add

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