Benchmark: array includes vs some vs indexOf

Script Preparation code:

var containedValue = '10079';
var notContainedValue = '79001';
var array = ['10000', '10001', '10002', '10003', '10004', '10005', '10006', '10007', '10008', '10009', '10010', '10011', '10012', '10013', '10014', '10015', '10016', '10017', '10018', '10019', '10020', '10021', '10022', '10023', '10024', '10025', '10026', '10027', '10028', '10029', '10030', '10031', '10032', '10033', '10034', '10035', '10036', '10037', '10038', '10039', '10040', '10041', '10042', '10043', '10044', '10045', '10046', '10047', '10048', '10049', '10050', '10051', '10052', '10053', '10054', '10055', '10056', '10057', '10058', '10059', '10060', '10061', '10062', '10063', '10064', '10065', '10066', '10067', '10068', '10069', '10070', '10071', '10072', '10073', '10074', '10075', '10076', '10077', '10078', '10079', '10080', '10081', '10082', '10083', '10084', '10085', '10086', '10087', '10088', '10089', '10090', '10091', '10092', '10093', '10094', '10095', '10096', '10097', '10098', '10099']

Tests:

Not contained: IndexOf
array.indexOf(notContainedValue) !== -1
Not contained: Includes
array.includes(notContainedValue)
Not contained: Some
array.some(v => v === notContainedValue)
Contained: IndexOf
array.indexOf(containedValue) !== -1
Contained: Includes
array.includes(containedValue)
Contained: Some
array.some(v => v === containedValue)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Not contained: IndexOf
Not contained: Includes
Not contained: Some
Contained: IndexOf
Contained: Includes
Contained: Some

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 break down the provided benchmark definition and test cases.

**Benchmark Definition**

The benchmark measures the performance of three different methods for checking if an element is present in an array:

1. `array.indexOf(notContainedValue) !== -1`
2. `array.includes(notContainedValue)`
3. `array.some(v => v === notContainedValue)`

These methods are compared to determine which one performs best.

**Options Compared**

The three options being compared are:

* `indexOf`: A method that returns the index of the first occurrence of the specified value, or -1 if it's not found.
* `includes`: A method that checks if an element is present in the array using a simple equality check.
* `some`: A method that tests whether at least one element in the array satisfies the provided condition.

**Pros and Cons**

Here are some pros and cons of each approach:

* `indexOf`:
	+ Pros: Can return the actual index of the element if found, which can be useful for indexing purposes. However, it returns -1 instead of a boolean value.
	+ Cons: May be slower than other methods due to its more complex implementation.
* `includes`:
	+ Pros: Simple and efficient, with an average time complexity of O(n).
	+ Cons: May use more memory if the array is very large, since it needs to store the entire array in memory.
* `some`:
	+ Pros: Very lightweight and easy to implement, making it a good choice for small arrays or performance-critical code.
	+ Cons: May return false positives if the condition is not met exactly (e.g., due to floating-point precision issues), although this can be mitigated with careful implementation.

**Libraries Used**

None are explicitly mentioned in the provided benchmark definition. However, it's likely that the `includes` method uses a library or internal implementation that relies on JavaScript's built-in array methods.

**Special JS Features/Syntax**

There doesn't seem to be any special JS features or syntax used in this benchmark (e.g., async/await, promises, destructuring).

**Other Alternatives**

Some other alternatives for checking if an element is present in an array include:

* `includes()` with a custom callback function
* Using a library like Lodash's `some()` method
* Implementing a custom search algorithm using binary search or other optimization techniques

In general, the choice of method depends on the specific use case and performance requirements. If simplicity and efficiency are key, `includes()` is likely a good choice. However, if indexing purposes are required, `indexOf()` might be more suitable. And for very large arrays or performance-critical code, custom optimizations or specialized libraries may be necessary.

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
Not contained: IndexOf	5996865.5 Ops/sec
Not contained: Includes	5978367.5 Ops/sec
Not contained: Some	293463.0 Ops/sec
Contained: IndexOf	6786898.5 Ops/sec
Contained: Includes	6776853.0 Ops/sec
Contained: Some	359215.5 Ops/sec

Related benchmarks:

array includes vs some vs indexOf (version: 0)

Comparing performance of: Not contained: IndexOf vs Not contained: Includes vs Not contained: Some vs Contained: IndexOf vs Contained: Includes vs Contained: Some

Created: one year ago by: Guest

Jump to the latest result

Not contained: IndexOf

Not contained: Includes

Not contained: Some

Contained: IndexOf

Contained: Includes

Contained: Some

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