Benchmark: test array.includes vs set.has 2

HTML Preparation code:

<!--your preparation HTML code goes here-->

Script Preparation code:

const TEST_SIZE = 1_000_000;
const searchPresent = "test_present";
const searchAbsent = "test_absent";

const data = [];
for (let i = 0; i < TEST_SIZE; i++) {
  data.push("string_" + i);
}
data.push(searchPresent);

const array = data.slice();
const set = new Set(data);

const amount = 10;

Tests:

Array.includes (присутній)
for (let i = 0; i < amount; i++) { array.includes("test_present"); }
Set.has (присутній)
for (let i = 0; i < amount; i++) { set.has("test_present"); }
Array.includes (відсутній)
for (let i = 0; i < amount; i++) { array.includes("test_absent"); }
Set.has (відсутній)
for (let i = 0; i < amount; i++) { set.has("test_absent"); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.includes (присутній)
Set.has (присутній)
Array.includes (відсутній)
Set.has (відсутній)

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 21 days ago)

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

Browser/OS: Firefox 137 on Windows

View result in a separate tab

Test name	Executions per second
Array.includes (присутній)	57.1 Ops/sec
Set.has (присутній)	117479696.0 Ops/sec
Array.includes (відсутній)	73.3 Ops/sec
Set.has (відсутній)	119769928.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 21 days ago):

LLMs can make mistakes. Check important info.

### Benchmark Overview: `test array.includes vs set.has 2`

This benchmark compares the performance of two JavaScript methods: `Array.includes()` and `Set.has()`. It evaluates their efficiency in determining whether a specific element is present in an array or a set, respectively.

### Comparison of Options

1. **Array.includes()**:
   - **Purpose**: This method checks if a certain value exists in the array and returns `true` or `false`.
   - **Use cases**: Suitable for search operations on small to medium-sized arrays where you need to check the presence of an item, especially if the order of elements is significant or if duplicates are acceptable.
   - **Performance**: The `includes` method has a time complexity of O(n), meaning it will scan the array linearly until it finds the value or reaches the end of the array. This can make it inefficient for large arrays.

2. **Set.has()**:
   - **Purpose**: This method checks if a certain value exists in a Set, which is a collection of unique values.
   - **Use cases**: Particularly useful for cases where you frequently check for existence (e.g., deduplication, membership testing). Sets are inherently optimized for fast lookups.
   - **Performance**: The `has` method has a time complexity of O(1), allowing for much faster membership checks compared to an array, especially as the size of the data grows.

### Benchmark Execution

The benchmark involves two scenarios for each method:
- Checking for a present value ("test_present").
- Checking for an absent value ("test_absent").

The `Script Preparation Code` initializes:
- A test size of one million elements, creating an array and a set filled with string values.
- The `array` variable is a traditional JavaScript array containing these values.
- The `set` variable is an instance of JavaScript's `Set`, which allows optimized value storage and lookup.

### Benchmark Results

From the benchmark results, we see:
- `Set.has()` outperforms `Array.includes()` significantly in both present and absent scenarios.
- The execution rates for `Set.has()` for both present (`117,479,696.0` executions per second) and absent (`119,769,928.0` executions per second) are dramatically higher than those for `Array.includes()`, which stand at `57.09511184692383` and `73.29843139648438` executions per second respectively.

### Pros and Cons

**Pros of Array.includes()**:
- Simple and straightforward for checking existence in small or moderate-sized arrays.
- Retains ordering and can work with duplicate values, which may be required in certain applications.

**Cons of Array.includes()**:
- Slower for large datasets due to linear search.
  
**Pros of Set.has()**:
- Extremely efficient for large datasets with constant time complexity.
- Automatically handles duplicates, storing only unique values.

**Cons of Set.has()**:
- More memory overhead due to the internal structure of Sets. 
- Not suitable for ordered collections or scenarios needing duplicates.

### Other Considerations

When choosing between these two methods, consider:
- **Dataset Size**: For small arrays, the difference in performance might be negligible.
- **Frequency of Searches**: Use `Set` when you require frequent checks on larger datasets.
- **Element Uniqueness**: If you need to maintain unique values, `Set` is the clear choice.
- **Readability**: Depending on the developer’s experience, one method may appear more readable than the other.

### Alternatives

Other alternatives to evaluate presence in arrays or collections include:
- **Map.has(key)**: Similar to `Set.has()`, but for key-value pairs, useful when you need to associate values with keys.
- **Using sorting or binary search**: For sorted arrays, employing a binary search can drastically improve lookup times (O(log n)), but requires that the array be sorted.
- **Using additional data structures**: Depending on the nature of the application, other data structures like trees or hash tables may also be appropriate for optimized membership tests.

In conclusion, selecting between `Array.includes()` and `Set.has()` largely depends on the specific use case, with `Set.has()` generally being the better option for performance in large datasets.

Related benchmarks:

test array.includes vs set.has 2 (version: 2)

Comparing performance of: Array.includes (присутній) vs Set.has (присутній) vs Array.includes (відсутній) vs Set.has (відсутній)

Created: 21 days ago by: Registered User

Jump to the latest result

Array.includes (присутній)

Set.has (присутній)

Array.includes (відсутній)

Set.has (відсутній)

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 21 days ago):