Benchmark: array find vs some vs includes (urls)

Tests:

array find
var a = ['www.startpage.com/do/metasearch.pl?q=foo+bar', 'www.startpage.com', 'en.m.wikipedia.org/wiki/AppleScript', 'developer.mozilla.com']; var b = a.find(item => item === 'developer.mozilla.com');
array some
var a = ['www.startpage.com/do/metasearch.pl?q=foo+bar', 'www.startpage.com', 'en.m.wikipedia.org/wiki/AppleScript', 'developer.mozilla.com']; var b = a.some(item => item === 'developer.mozilla.com');
array includes
var a = ['www.startpage.com/do/metasearch.pl?q=foo+bar', 'www.startpage.com', 'en.m.wikipedia.org/wiki/AppleScript', 'developer.mozilla.com']; var b = a.includes('developer.mozilla.com');
array indexOf
var a = ['www.startpage.com/do/metasearch.pl?q=foo+bar', 'www.startpage.com', 'en.m.wikipedia.org/wiki/AppleScript', 'developer.mozilla.com']; var b = a.indexOf('developer.mozilla.com');

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
array find
array some
array includes
array indexOf

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; rv:109.0) Gecko/20100101 Firefox/111.0

Browser/OS: Firefox 111 on Windows

View result in a separate tab

Test name	Executions per second
array find	50682184.0 Ops/sec
array some	48196384.0 Ops/sec
array includes	48240876.0 Ops/sec
array indexOf	43502056.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down what's being tested in the provided JSON.

The benchmark is testing four different ways to check if an element exists in an array:

1. `Array.prototype.find()`: Returns the first element that satisfies the provided condition.
2. `Array.prototype.some()`: Returns a boolean indicating whether at least one element in the array satisfies the provided condition.
3. `Array.prototype.includes()`: Returns a boolean indicating whether the specified value is present in the array.
4. `Array.prototype.indexOf()`: Returns the index of the first occurrence of the specified value in the array.

Now, let's discuss the pros and cons of each approach:

**1. Array.prototype.find():**

Pros:

* Returns the actual element that matches the condition, making it useful for retrieving the matched value.
* More concise than `some()` or `includes()`, which can be beneficial for readability.

Cons:

* May not be as efficient as other methods if no match is found, as it has to traverse the array until finding a suitable element.
* Can throw an error if no match is found (depending on how it's used), whereas `some()` and `includes()` return a boolean value.

**2. Array.prototype.some():**

Pros:

* Returns a boolean indicating whether any element in the array satisfies the condition, making it useful for checking multiple conditions simultaneously.
* More efficient than `find()` when no match is found, as it can stop traversing the array immediately.

Cons:

* Returns a boolean value, which might not be as convenient as getting the actual matched value like with `find()`.
* Can be less readable if used in complex scenarios.

**3. Array.prototype.includes():**

Pros:

* Fast and efficient, making it suitable for large arrays or performance-critical code.
* Returns a simple boolean indicating whether the element is present, without throwing an error on no-match cases.

Cons:

* Only returns a boolean value, not the actual matched element, which might be less useful in certain scenarios.

**4. Array.prototype.indexOf():**

Pros:

* Fast and efficient, similar to `includes()`.
* Returns the index of the first occurrence, making it useful for accessing elements by their position.

Cons:

* Returns -1 if no match is found, whereas other methods return a boolean value or an error (depending on how they're used).

Now, let's discuss special considerations and libraries used in the benchmark:

The test cases use `var` declarations with arrow functions (`=>`) for simplicity. There are no notable libraries being used in these examples.

Some special JavaScript features used here include:

* Arrow functions (`=>`)
* Template literals (used for multiline strings)

Keep in mind that modern JavaScript development often focuses on more recent features like classes, modules, and async/await.

As for alternatives, other methods to check if an element exists in an array include:

* Using `for...of` loop or `forEach()` with a callback function
* Utilizing `Array.prototype.includes()` with the same syntax as shown in the benchmark (e.g., `a.includes('developer.mozilla.com')`)
* Implementing a custom search function using indexing and bounds checking

These alternatives may offer varying trade-offs in terms of performance, readability, or convenience.

Related benchmarks:

array find vs some vs includes (urls) (version: 0)

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

Created: one year ago by: Guest

Jump to the latest result

array find

array some

array includes

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