Benchmark: Number array indexOf vs includes vs some

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 = [1, 2, 3]

Tests:

IndexOf
array.indexOf(3) !== 1
Includes
array.includes(3)
some
array.some(v => v == 3)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
IndexOf
Includes
some

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the provided benchmark definition and test cases.

**Benchmark Definition**

The benchmark definition json represents a comparison of three different approaches to find if an array contains a specific value: `indexOf`, `includes`, and `some`. The benchmark measures the performance of these approaches in JavaScript, which is used as the programming language for the test.

**Approaches Compared**

1. **`array.indexOf(3) !== 1`**: This approach uses the `indexOf` method to find the index of a specific value (3) in the array. If the value is not found at the expected position (index 1), it returns -1, which is considered "not equal" to 1.
2. **`array.includes(3)`**: This approach uses the `includes` method to check if a specific value (3) is present in the array.
3. **`array.some(v => v == 3)`**: This approach uses the `some` method with an arrow function that checks if each element of the array is equal to 3.

**Pros and Cons of Each Approach**

1. **`indexOf`**:
	* Pros: Fast and efficient, as it only iterates through a limited range of elements.
	* Cons: May not be suitable for large arrays or when the value is not present in the first few elements.
2. **`includes`**:
	* Pros: More concise and readable than `indexOf`, with better performance on modern browsers.
	* Cons: May use more memory, as it needs to create an iterator over the array.
3. **`some`**:
	* Pros: More flexible and expressive, allowing for early termination if a match is found.
	* Cons: May be slower than `indexOf` or `includes`, especially for large arrays.

**Library Usage**

The benchmark uses Lodash, a popular JavaScript library that provides various utility functions. In this case, the `lodash.min.js` file is included in the HTML preparation code to provide the `includes` method implementation.

**Special JS Features or Syntax**

None of the test cases use any special JavaScript features or syntax beyond what's standard for modern browsers.

**Alternatives**

If you're interested in exploring alternative approaches, here are a few options:

1. **Manual iteration**: Use a loop to iterate through the array and check each element manually.
2. **Regular expressions**: Use regular expressions to search for the value in the array.
3. **Native methods**: Use native JavaScript methods like `find()` or `forEach()` instead of `indexOf`, `includes`, or `some`.

Keep in mind that these alternatives may have different performance characteristics and might not be as concise or readable as the original approaches.

I hope this explanation helps you understand the benchmark definition and test cases!

Latest run results:

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

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

Browser/OS: Chrome 93 on Linux

View result in a separate tab

Test name	Executions per second
IndexOf	17913912.0 Ops/sec
Includes	19535236.0 Ops/sec
some	18757846.0 Ops/sec

Related benchmarks:

Number array indexOf vs includes vs some (version: 0)

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

Comparing performance of: IndexOf vs Includes vs some

Created: 3 years ago by: Guest

Jump to the latest result

IndexOf

Includes

some

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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