Benchmark: JS find vs indexOf with string

Script Preparation code:

var arr = [];
var i = 0;

while (i <= 1E5) arr[i] = String(i++);

Tests:

Array.find
const item = arr.find(item => item == 1E5);
Array.indexOf
const index = arr.indexOf(1E5);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.find
Array.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.

Let's break down the benchmark and explain what's being tested.

**Benchmark Overview**

The benchmark compares two methods for finding an element in an array: `Array.prototype.find()` and `Array.prototype.indexOf()`. Both methods are used to locate a specific value (`1E5`) within the array.

**Options Compared**

Two options are compared:

1. **`Array.prototype.find()`**: This method returns the first element in the array that satisfies the provided testing function.
2. **`Array.prototype.indexOf()`**: This method returns the index of the first occurrence of the specified value in the array.

**Pros and Cons**

* `Array.prototype.find()`
	+ Pros:
		- More concise and expressive than `indexOf`, as it takes a callback function to specify the condition for finding the element.
		- Returns the found element, not just its index.
	+ Cons:
		- May be slower for large arrays, as it requires iterating through the array until it finds the matching element.
		- May return `undefined` if no element is found.
* `Array.prototype.indexOf()`
	+ Pros:
		- Faster than `find()` for large arrays, as it uses a linear search algorithm to find the index of the first occurrence.
		- Returns the index of the first occurrence, not just the value itself.
	+ Cons:
		- Less concise and less expressive than `find()`, as it requires specifying the value to search for explicitly.

**Other Considerations**

* Both methods are supported by modern JavaScript engines and are widely used in development frameworks.
* The `Array.prototype.find()` method was introduced in ECMAScript 2015 (ES6) and is now a part of the standard language specification.
* The `Array.prototype.indexOf()` method has been available since ECMAScript 1999 (ES3).

**Library Used**

None, as this benchmark only uses built-in JavaScript methods.

**Special JS Feature or Syntax**

No special features or syntax are used in this benchmark. Both methods use a simple array and the `1E5` value, which is a numeric literal.

**Other Alternatives**

If you need to find an element in an array but don't want to use `Array.prototype.find()` or `Array.prototype.indexOf()`, you can consider using other approaches:

* Using a `for...of` loop to iterate through the array and check each element manually.
* Using a library like Lodash, which provides a more functional programming style for working with arrays.

However, these alternatives are likely to be less efficient and less concise than using `Array.prototype.find()` or `Array.prototype.indexOf()`.

Latest run results:

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

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

Browser/OS: Chrome 103 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Array.find	708.3 Ops/sec
Array.indexOf	71945.1 Ops/sec

Related benchmarks:

JS find vs indexOf with string (version: 0)

JS find vs indexOf

Comparing performance of: Array.find vs Array.indexOf

Created: 2 years ago by: Guest

Jump to the latest result

Array.find

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