Benchmark: set includes vs array includes for two values

Script Preparation code:

var valueArray = [1, 2]; 
var valueSet = new Set([1, 2]);

Tests:

array (first case)
for (var i = 0; i < 1e7; ++i) { valueArray.includes(1); }
array (second case)
for (var i = 0; i < 1e7; ++i) { valueArray.includes(2); }
Set (first case)
for (var i = 0; i < 1e7; ++i) { valueSet.has(1); }
Set (second case)
for (var i = 0; i < 1e7; ++i) { valueSet.has(2); }
Set (no case)
for (var i = 0; i < 1e7; ++i) { valueArray.includes(3); }
array (no case)
for (var i = 0; i < 1e7; ++i) { valueSet.has(3); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
array (first case)
array (second case)
Set (first case)
Set (second case)
Set (no case)
array (no case)

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll break down what's being tested in this benchmark and explain the options, pros, cons, and other considerations.

**What's being tested:**
The benchmark is designed to compare the performance of two approaches:

1. **Array includes**: Using the `includes()` method on an array to check for the presence of a specific value.
2. **Set lookups**: Using the `has()` method on a Set data structure to check for the presence of a specific value.

The test cases cover different scenarios, including:

* Checking for a value that is present in the set/array (e.g., `1` and `2`)
* Checking for a value that is not present in the set/array (e.g., `3`)

**Options compared:**

* **Array includes**: Using the `includes()` method on an array
* **Set lookups**: Using the `has()` method on a Set data structure

**Pros and Cons of each approach:**

* **Array includes**:
	+ Pros:
		- Wide browser support (most modern browsers)
		- Simple to implement
	+ Cons:
		- Can be slower for large arrays due to linear search
		- May not perform well for sparse arrays (i.e., arrays with many null or undefined values)
* **Set lookups**:
	+ Pros:
		- Can be faster than array includes for large datasets
		- Reduces the number of operations required when checking multiple values
	+ Cons:
		- Limited browser support (older browsers may not support Sets)
		- May require more memory to store the Set data structure

**Library used:**
In this benchmark, the `Set` library is used. A Set is a collection of unique values that allows for efficient lookups using the `has()` method.

**Special JavaScript features or syntax:**
None mentioned in the provided benchmark definition.

**Other considerations:**

* **Browser-specific optimizations**: Different browsers may optimize array includes and set lookups differently, which can affect performance.
* **Data distribution**: The benchmark results are likely influenced by the specific data distribution used in the test cases (e.g., random values vs. sequential values).
* **Cache effects**: Cache effects can impact performance for array includes, especially when dealing with large arrays.

**Alternatives:**
If you're interested in exploring alternative approaches or libraries, consider the following:

* **Using sparse arrays**: If you have a sparse array and only need to check for specific values that are present, using sparse arrays might be faster than regular arrays.
* **Using hash tables**: Some JavaScript engines (e.g., V8) use hash tables under the hood for certain operations. You can experiment with using `Map` or other hash table-like data structures to see if they outperform array includes and set lookups.
* **Optimized libraries**: Some optimized libraries, such as `fast-set` or `Set-fast`, aim to improve performance for set lookups.

Keep in mind that these alternatives might not be compatible with all browsers or versions. Always test thoroughly before integrating new code or libraries into your project.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:76.0) Gecko/20100101 Firefox/76.0

Browser/OS: Firefox 76 on Windows

View result in a separate tab

Test name	Executions per second
array (first case)	21.2 Ops/sec
array (second case)	16.7 Ops/sec
Set (first case)	4.7 Ops/sec
Set (second case)	4.7 Ops/sec
Set (no case)	17.8 Ops/sec
array (no case)	4.7 Ops/sec

Related benchmarks:

set includes vs array includes for two values (version: 0)

Check whether Set look ups are faster than Array includes even when there's only two values

Comparing performance of: array (first case) vs array (second case) vs Set (first case) vs Set (second case) vs Set (no case) vs array (no case)

Created: 5 years ago by: Guest

Jump to the latest result

array (first case)

array (second case)

Set (first case)

Set (second case)

Set (no case)

array (no case)

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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