Benchmark: Set.has VS Array.some

Tests:

Set.has multiple
const oldData = Array.from({ length: 500 }, (x, i) => ({ id: String(i), x: 0, y: 0 })); const newData = Array.from({ length: 50 }, (x, i) => ({ id: String(i * 10), x: 1, y: 1 })); const oldDataSet = new Set(oldData.map((od) => od.id)); for (const nd of newData) { const has = oldDataSet.has(nd.id); }
Array.some multiple
const oldData = Array.from({ length: 500 }, (x, i) => ({ id: String(i), x: 0, y: 0 })); const newData = Array.from({ length: 50 }, (x, i) => ({ id: String(i * 10), x: 1, y: 1 })); for (const nd of newData) { const has = oldData.some((od) => od.id === nd.id); }
Set.has single
const oldData = Array.from({ length: 500 }, (x, i) => ({ id: String(i), x: 0, y: 0 })); const findId = "450"; const oldDataSet = new Set(oldData.map((od) => od.id)); const has = oldDataSet.has(findId);
Array.some single
const oldData = Array.from({ length: 500 }, (x, i) => ({ id: String(i), x: 0, y: 0 })); const findId = "450"; const has = oldData.some((od) => od.id === findId);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Set.has multiple
Array.some multiple
Set.has single
Array.some single

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 dive into the world of JavaScript microbenchmarks!

**What is being tested?**

MeasureThat.net is testing two different approaches to check if an element exists in an array or set:

1. **Array.prototype.some()**: This method returns a boolean value indicating whether at least one element in the array satisfies the provided test.
2. **Set.prototype.has()**: This method returns a boolean value indicating whether the specified element exists in the set.

**Options being compared**

The benchmark is comparing four different scenarios:

1. **Array some single**: Checking if an element exists in the entire array using `Array.some()`.
2. **Set has single**: Checking if an element exists in the set created from a subset of the array using `Set.prototype.has()`.
3. **Set has multiple**: Checking if an element exists in the set created from the full array using `Set.prototype.has()`.
4. **Array some multiple**: Checking if an element exists in any part of the array (not just the entire array) using `Array.some()`.

**Pros and Cons**

Here's a brief summary of each approach:

* **Array.some single**:
	+ Pros: Simple, straightforward, and easy to understand.
	+ Cons: May be slower than other approaches since it checks every element in the array.
* **Set has single**:
	+ Pros: Fast and efficient for looking up elements in a set.
	+ Cons: Requires creating an additional set from a subset of the data, which can be memory-intensive.
* **Set has multiple**:
	+ Pros: Similar to `Set.has single` but uses the full array, which might be more representative of real-world use cases.
	+ Cons: Still requires creating a set, and its performance is dependent on the size of the set.
* **Array.some multiple**:
	+ Pros: May be faster than other approaches since it only checks if an element exists in any part of the array.
	+ Cons: Less straightforward than `Array.some single` since it returns a boolean value indicating whether at least one element satisfies the test.

**Libraries and special JS features**

No specific libraries or special JS features are mentioned in this benchmark definition. However, it's worth noting that some browsers may have optimizations for certain methods (e.g., Chrome's `Set.prototype.has()` implementation).

**Other considerations**

When choosing an approach, consider the following factors:

* Data size: For large datasets, using a set or other optimized data structures might be more efficient.
* Performance requirements: If speed is crucial, consider using optimized methods like `Set.prototype.has()`.
* Code simplicity and readability: Choose an approach that aligns with your coding style and maintainability needs.

**Alternatives**

Other alternatives for checking if an element exists in an array or set include:

* **Using a custom lookup table**: Creating a precomputed lookup table can be faster than using `Array.some()` or `Set.prototype.has()`.
* **Using SIMD instructions**: If you're working with large datasets and need optimal performance, consider using SIMD (Single Instruction, Multiple Data) instructions.
* **Using a specialized library**: Libraries like [fast-set](https://github.com/valtimo/fast-set) provide optimized implementations for set operations.

Keep in mind that these alternatives may have additional requirements, such as memory allocation or specific browser support.

Latest run results:

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

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

Browser/OS: Chrome 130 on Windows

View result in a separate tab

Test name	Executions per second
Set.has multiple	10044.9 Ops/sec
Array.some multiple	7419.4 Ops/sec
Set.has single	11275.8 Ops/sec
Array.some single	12096.6 Ops/sec

Related benchmarks:

Set.has VS Array.some (version: 0)

Comparing performance of: Set.has multiple vs Array.some multiple vs Set.has single vs Array.some single

Created: 2 months ago by: Guest

Jump to the latest result

Set.has multiple

Array.some multiple

Set.has single

Array.some single

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