Benchmark: array indexOf vs includes vs some vs set.has

HTML Preparation code:


<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>

Script Preparation code:

var array = ['banana','test0','test1','test2','test3','test4','test5','test6','test7','test8','test9','test10','sausage', 'jesus'];
var set = new Set(array)

Tests:

IndexOf
array.indexOf('sausage') !== 1
Includes
array.includes('sausage')
Some
array.some(v => v === 'sausage')
Set
set.has('sausage')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
IndexOf
Includes
Some
Set

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36

Browser/OS: Chrome 133 on Linux

View result in a separate tab

Test name	Executions per second
IndexOf	60784504.0 Ops/sec
Includes	60219080.0 Ops/sec
Some	75668920.0 Ops/sec
Set	190597936.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 2 months ago):

LLMs can make mistakes. Check important info.

The benchmark defined in the provided JSON is focused on comparing different methods for determining whether an array contains a specific value, specifically the string 'sausage'. It compares the performance of four distinct approaches:

### Benchmark Options

1. **`array.indexOf('sausage') !== -1`**
   - **Description**: This method uses the `indexOf` function to find the index of the specified element. If the element is not found, `indexOf` returns `-1`; thus, a comparison is made to check if the result is not `-1`.
   - **Pros**: It is compatible with older browsers, as `indexOf` is widely supported.
   - **Cons**: It doesn't explicitly convey intent in the way that more descriptive methods (like `includes`) do, and it will return `-1` even for `null` or `undefined` entries, potentially causing misleading outcomes if those values are in the array.

2. **`array.includes('sausage')`**
   - **Description**: This method checks if the array contains a particular element, returning a boolean value (true/false).
   - **Pros**: It is more readable and clearly expresses the intent of checking for the existence of a value. It is also type-safe, meaning it will only return `false` for values that aren't present, while treating `null` and `undefined` distinctly.
   - **Cons**: Slightly less optimized than `indexOf`, and may not be supported in older environments without transpilation.

3. **`array.some(v => v === 'sausage')`**
   - **Description**: The `some` method tests whether at least one element in the array passes the provided test function (in this case, checking equality).
   - **Pros**: It allows greater flexibility as it can use any condition in the provided function. This can be useful for more complex checks beyond simple equality.
   - **Cons**: The overhead of a function call for each element can lead to decreased performance, especially in larger arrays.

4. **`set.has('sausage')`**
   - **Description**: This utilizes a `Set` object to check the presence of an element, which provides a more efficient lookup for membership.
   - **Pros**: Sets are optimized for fast lookups (typically O(1) time complexity) compared to arrays, making them very efficient when checking for the existence of elements.
   - **Cons**: The overhead of creating a `Set` can negate the performance benefits for small datasets since it reprioritizes resource allocation.

### Results Overview

The benchmark results indicate that, on the tested environment:

- **Set**: Fastest with 190,597,936 executions per second.
- **Some**: Next best performer at 75,668,920 executions per second. 
- **IndexOf**: Less efficient at 60,784,504 executions per second.
- **Includes**: Slightly slower than `IndexOf` at 60,219,080 executions per second.

### Additional Considerations

- **Library**: The HTML preparation code includes a reference to Lodash, a JavaScript utility library that provides functions for common programming tasks, like working with arrays, collections, and objects. However, this benchmark does not utilize any Lodash functions as it directly tests native JavaScript methods.
- **Use Cases**: In practice, the choice of method depends on the specific requirements such as array size, frequency of searches, and overall performance considerations in the context of the application. For example, if the data being handled is large and the same checks are done multiple times, converting the data to a `Set` may yield significant performance enhancements.

### Alternatives

Apart from the methods tested, other alternatives include:

- **Using an object as a set**: Similar to a `Set`, you could manage keys in a plain object for fast lookups.
- **Binary Search on Sorted Arrays**: If the array is sorted, a binary search algorithm could be employed to improve lookup performance, but this requires the array to be sorted first and may not be efficient for unsorted data.
- **Third-party libraries**: For even more performance, more specialized libraries (like Immutable.js) could offer additional data structures and methods engineered for high performance in specific use cases.

In conclusion, selecting the right method for checking the presence of an element largely depends on the specifics of the data and the application's performance needs. The benchmark serves as a helpful guide for making these decisions.

Related benchmarks:

array indexOf vs includes vs some vs set.has (version: 1)

performance comparison of ways to find if an array contains a value

Comparing performance of: IndexOf vs Includes vs Some vs Set

Created: 2 months ago by: Guest

Jump to the latest result

IndexOf

Includes

Some

Set

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 2 months ago):