Benchmark: includes vs set 1241 2341234 1233

Script Preparation code:

var arr = Array(100000).fill(1).map((_, index) => index);
arr[arr.length - 1] = -1;

var set = new Set();

arr.forEach((item) => set.add(item));

Tests:

arr.includes
arr.includes(-1);
set.has
set.has(-1)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
arr.includes
set.has

Fastest: N/A

Slowest: N/A

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/103.0.5060.114 Safari/537.36 OPR/89.0.4447.64 (Edition GX-CN)

Browser/OS: Opera 89 on Windows

View result in a separate tab

Test name	Executions per second
arr.includes	26384.7 Ops/sec
set.has	13163363.0 Ops/sec

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

LLMs can make mistakes. Check important info.

I'd be happy to help explain the benchmark and provide insights on the options being compared.

**Benchmark Overview**

The provided benchmark measures the performance of two common JavaScript operations: `arr.includes(-1)` and `set.has(-1)`. The test cases use an array `arr` with 100,000 elements filled with numbers from 0 to 99,999, and then sets up a new Set `set` containing these elements. The benchmark tests the performance of finding the presence of the element -1 in both the array using `includes()` and the set using `has()`, with a single iteration over the data.

**Options Being Compared**

There are two main options being compared:

1. **Array.includes()**: This method checks if a specified value (in this case, -1) exists in the array.
2. **Set.has()**: This method checks if an element exists in the set.

**Pros and Cons of Each Approach**

**Array.includes():**

Pros:

* More intuitive and widely supported, as it's similar to the `indexOf()` method used for arrays.
* Can be optimized more aggressively by modern browsers, since it only needs to scan the array until the first occurrence of -1.

Cons:

* May perform slower than Set.has() due to the need to traverse the entire array. However, this difference is usually negligible in most real-world scenarios.

**Set.has():**

Pros:

* Generally faster and more efficient, especially for large datasets, since it only needs to check a single element against the set.
* Reduces the search space, making it more suitable for situations where exact matching is required (e.g., in databases or data storage).

Cons:

* Less intuitive and may require additional setup or library dependencies for usage outside of Set objects.

**Library/Implementation Considerations**

In this benchmark, no libraries are explicitly used. However, the behavior of `includes()` and `has()` methods can be influenced by the underlying implementation, such as:

* Browser-specific optimizations (e.g., WebKit vs Blink).
* Platform-specific differences in performance characteristics.
* Potential for future changes or updates to the specification.

**Special JS Features/Syntax**

In this benchmark, no special JavaScript features or syntax are explicitly used. However, it's worth noting that modern browsers have introduced additional optimizations and performance enhancements for various operations, such as:

* `Map` instances providing faster lookups than `Set`.
* Using `Array.prototype.find()` instead of `includes()`.
* `Symbol.has()` (not applicable in this case).

**Alternative Implementations**

For those interested in exploring alternative implementations or optimizing the code further, here are some examples:

* For Array.includes(), consider using a more optimized version like `arr.indexOf(-1)`, which may perform better on specific browsers.
* For Set.has(), you could use native WebAssembly (WASM) optimizations to improve performance for very large datasets.

Keep in mind that optimizations and trade-offs will depend on the specific requirements, target audience, and platform of your application.

Related benchmarks:

includes vs set 1241 2341234 1233 (version: 0)

Comparing performance of: arr.includes vs set.has

Created: 2 years ago by: Guest

Jump to the latest result

arr.includes

set.has

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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