Benchmark: array find vs some vs includes

HTML Preparation code:

<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.core.js"></script>

Tests:

array some
var a = ['hello', 'a', 'bc']; var b = a.some(item => item === 'bc');
array includes
var a = ['hello', 'a', 'bc']; var b = a.includes('bc');
array find
var a = ['hello', 'a', 'bc']; var b = a.find(item => item === 'bc');

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
array some
array includes
array find

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36

Browser/OS: Chrome 119 on Windows

View result in a separate tab

Test name	Executions per second
array some	198478592.0 Ops/sec
array includes	1043913408.0 Ops/sec
array find	201761040.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark definition and test cases.

**Benchmark Definition**

The benchmark compares three different ways to check if an element exists in an array: using the `some()` method, the `includes()` method, and the `find()` method.

**Options Compared**

1. **`some()`**: This method returns `true` as soon as it finds an element that satisfies the callback function. It's used to check if at least one element of an array matches a condition.
2. **`includes()`**: This method returns `true` if the array includes the specified value, otherwise `false`. It's similar to `some()`, but only checks for exact match.
3. **`find()`**: This method returns the first element in the array that satisfies the callback function. If no elements are found, it returns `undefined`.

**Pros and Cons**

* **`some()`**:
	+ Pros: Efficient way to check if at least one element matches a condition.
	+ Cons: Returns `true` as soon as it finds a match, which might not be desirable in all cases.
* **`includes()`**:
	+ Pros: Similar to `some()`, but only checks for exact match, which can be useful in certain scenarios.
	+ Cons: Might be slower than `some()` since it uses string comparison.
* **`find()`**:
	+ Pros: Returns the first matching element, which can be useful in some cases.
	+ Cons: Returns `undefined` if no elements are found, which can lead to unexpected behavior.

**Library**

The benchmark uses Lodash, a popular JavaScript utility library, which provides the `some()`, `includes()`, and `find()` methods. The Lodash library is not necessary for this benchmark, but it's likely used here to ensure consistency across different implementations.

**Special JS Feature/Syntax**

There are no special JavaScript features or syntaxes being tested in this benchmark. It's focused on comparing the performance of three specific array methods.

**Other Alternatives**

Other alternatives for checking if an element exists in an array include:

* Using a `for` loop with indexing: `for (var i = 0; i < arr.length; i++) { if (arr[i] === value) { ... } }`
* Using the `in` operator: `if (value in arr) { ... }`
* Using the `Array.prototype.every()` method, which returns `true` only if no elements are found that don't match the condition.

However, these alternatives might not be as efficient or convenient as using built-in array methods like `some()`, `includes()`, and `find()`.

Related benchmarks:

array find vs some vs includes (version: 0)

Compare the new ES6 spread operator with the traditional concat() method

Comparing performance of: array some vs array includes vs array find

Created: 3 years ago by: Guest

Jump to the latest result

array some

array includes

array find

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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