Benchmark: Array access vs set access time

Script Preparation code:

var arrData = [];
var setData = new Set();

var iter = 100;

for (i = 0; i < iter; i++) {
    arrData.push(i);
    setData.add(i);
}

Tests:

Array access
for (i = 0; i < (iter * 2); i++) { if (arrData.includes(i)) {} }
Set access
for (i = 0; i < (iter * 2); i++) { if (setData.has(i)) {} }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array access
Set access

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36

Browser/OS: Chrome 124 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Array access	71698.4 Ops/sec
Set access	71006.1 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into explaining the benchmark.

The provided JSON represents a JavaScript microbenchmark that tests two different approaches to perform set operations: array access and set access. The goal is to compare the performance of these two methods in finding elements within a set of data.

**Script Preparation Code**

Before running the benchmark, the script preparation code creates an empty array `arrData` and a new Set `setData`. It then sets up a loop that iterates 100 times (`iter = 100`). Within this loop:

1. The array `arrData` is populated with numbers from 0 to 199 (i.e., `i`) using the `push()` method.
2. A number `i` is added to the Set `setData` using the `add()` method.

This setup creates a set of data that contains duplicate values, which will be used for testing.

**Html Preparation Code**

Since there is no HTML preparation code provided, we can assume that it's not necessary for this particular benchmark. The focus is on comparing the performance of JavaScript engines when executing these two different approaches.

**Options Compared**

Two options are compared:

1. **Array Access**: This approach uses the `includes()` method to check if an element is present in the array.
2. **Set Access**: This approach uses the `has()` method to check if an element is present in the set.

**Pros and Cons of Each Approach**

* **Array Access (includes())**:
	+ Pros: More intuitive for developers familiar with arrays, as it's a common operation.
	+ Cons: May be slower due to the overhead of iterating over the array to find the desired element.
* **Set Access (has())**:
	+ Pros: Generally faster than array access, especially for large sets, since sets use a hash table for lookup.
	+ Cons: Less intuitive for developers unfamiliar with sets, as it's not a common operation.

**Library Usage**

There is no explicit library usage in this benchmark. However, the `Set` object and its methods (`add()` and `has()`) are part of the JavaScript standard library.

**Special JS Features/Syntax**

This benchmark doesn't use any special JavaScript features or syntax beyond what's necessary for testing these two approaches.

**Alternative Approaches**

Other alternatives to compare in this type of benchmark could include:

1. **Using a different data structure**, such as a linked list or a tree, instead of an array or set.
2. **Implementing the `includes()` method from scratch`, which would allow comparing its performance with the built-in implementation.
3. **Comparing the performance of other set operations**, such as `forEach()`, `filter()`, or `some()`.
4. **Using a different JavaScript engine** or configuration to see how it affects the benchmark results.

Keep in mind that these alternatives might require modifying the benchmark script and setup, but they could provide additional insights into JavaScript performance and optimization.

Related benchmarks:

Array access vs set access time (version: 0)

Comparing performance of: Array access vs Set access

Created: one year ago by: Guest

Jump to the latest result

Array access

Set access

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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