Benchmark: Includes vs Some vs IndexOf

Script Preparation code:

var arr = [];
arr.push('A');
arr.push('B');
arr.push('C');
arr.push('D');
arr.push('E');
arr.push('F');
arr.push('G');
arr.push('H');
arr.push('I');

Tests:

Includes
var tempResult = arr.includes(v => v === 'E');
Some
var tempResult = arr.some(v => v === 'E');
IndexOf
var tempResult = arr.indexOf('E') > -1;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Includes
Some
IndexOf

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided benchmark compares the performance of three methods to find an element in an array: `includes`, `some`, and `indexOf`. The benchmark is run on a fixed input array with 12 elements.

**Options Compared**

* **`includes(v => v === 'E')`**: This method uses the arrow function syntax to define a function that checks if an element is equal to `'E'`. It returns a boolean value indicating whether the element is found or not.
* **`arr.some(v => v === 'E')`**: This method uses the `some()` array method, which returns a boolean value indicating whether at least one element in the array satisfies the provided condition.
* **`arr.indexOf('E') > -1`**: This method uses the `indexOf()` array method to find the index of the specified element. If the element is found, it returns its index; otherwise, it returns `-1`.

**Pros and Cons of Each Approach**

* **`includes(v => v === 'E')`**:
	+ Pros: concise syntax, easy to read.
	+ Cons: may have performance overhead due to the arrow function creation and invocation.
* **`arr.some(v => v === 'E')`**:
	+ Pros: can be faster than `includes()` for large arrays since it stops iterating as soon as a match is found.
	+ Cons: may not be as readable as `includes()`, and the condition must be a function expression.
* **`arr.indexOf('E') > -1`**:
	+ Pros: well-established method with good performance, easy to understand.
	+ Cons: returns an index value instead of a boolean result.

**Library**

There is no library explicitly mentioned in the benchmark. However, some browsers may have built-in polyfills or implementations for these methods.

**Special JS Features**

* **Arrow Function Syntax**: used in `includes(v => v === 'E')` and `arr.some(v => v === 'E')`. This feature allows defining small, single-expression functions using the `=>` syntax.
* **Template Literals**: not explicitly mentioned, but the HTML Preparation Code does not include any template literal usage.

**Other Considerations**

* The benchmark only tests these three methods on a fixed input array. In practice, you may need to test different scenarios and edge cases for each method.
* The benchmark results are provided in UAP (User Agent Platform) string format, which includes information about the browser, device platform, operating system, and other metadata.

**Alternatives**

If you're interested in exploring alternative methods or optimizations, here are a few options:

* **Using `find()` instead of `includes()`**: `find()` can be faster for large arrays since it returns the first element that matches the condition, whereas `includes()` returns a boolean value.
* **Using `filter()` instead of `some()`**: `filter()` can be used to find all elements that match a condition, which might be useful in some scenarios.
* **Optimizing `indexOf()`**: Some browsers have optimized implementations for `indexOf()`, such as using a binary search algorithm. However, these optimizations may not be available on all platforms or versions.

Keep in mind that the optimal approach depends on your specific use case and requirements.

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/537.36

Browser/OS: Chrome 117 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Includes	28588562.0 Ops/sec
Some	27849108.0 Ops/sec
IndexOf	26959976.0 Ops/sec

Related benchmarks:

Includes vs Some vs IndexOf (version: 0)

Comparing performance of: Includes vs Some vs IndexOf

Created: 4 years ago by: Guest

Jump to the latest result

Includes

Some

IndexOf

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