Benchmark: array.indexof vs for

Script Preparation code:

var a=[];
a.length=1000;
a.fill(0);
a[500]=123;
a[998]=234;

Tests:

indexof
a.slice(a.indexOf(123),a.indexOf(234));
for
let i=0; let st=0; while(i<a.length){ if(a[i]===123){ break; st=i; } i+=1; } let ed=0; while(i<a.length){ if(a[i]===234){ break; ed=i; } i+=1; } a.slice(st,ed);
indexof 2
const st=a.indexOf(123); a.slice(st,a.slice(st).indexOf(234));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
indexof
for
indexof 2

Fastest: N/A

Slowest: N/A

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/126.0.0.0 Safari/537.36

Browser/OS: Chrome 126 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
indexof	2602812.8 Ops/sec
for	15827.7 Ops/sec
indexof 2	3185848.0 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Explanation**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks. The provided JSON represents a benchmark test case for the comparison of different approaches to finding an element in an array.

**Test Case: Array.indexOf vs For**

The benchmark tests three different approaches to find an element (123) in the array `a`:

1. **Array.indexOf**: Using the built-in `indexOf()` method to search for 123.
2. **For Loop**: Implementing a traditional for loop to iterate through the array and find 123.
3. **Indexof 2**: Using the `indexOf()` method twice, once to find the index of 123, and then using that index to find the next occurrence of 234.

**Comparison**

The pros and cons of each approach are:

* **Array.indexOf**:
	+ Pros: Fast and efficient, as it uses a optimized algorithm under the hood.
	+ Cons: May not work as expected if the array is very large or has many duplicates, as it uses a linear search algorithm.
* **For Loop**:
	+ Pros: Can be more flexible and easier to understand for those familiar with traditional programming approaches.
	+ Cons: Generally slower than `indexOf()` due to the overhead of manual iteration.
* **Indexof 2**:
	+ Pros: May be faster than a single call to `indexOf()`, as it avoids re-searching for 123.

**Other Considerations**

* The benchmark assumes that the array is populated with 1000 elements, all initially set to 0, except for two specific indices (500 and 998) which are set to 123 and 234, respectively.
* The `slice()` method is used to extract a subset of the array after finding the indices.

**Library**

None. This benchmark uses only built-in JavaScript methods and variables.

**Special JS Feature/Syntax**

None mentioned in this specific benchmark. However, some newer browsers may optimize or implement features that could affect the results, such as Web Workers or async/await.

**Alternatives**

Other approaches to find an element in an array might include:

* Using `find()` or `findIndex()` methods
* Implementing a binary search algorithm
* Using a library like Lodash or Ramda for more complex operations

Note that the choice of approach depends on the specific requirements and constraints of the project.

Related benchmarks:

array.indexof vs for (version: 0)

Comparing performance of: indexof vs for vs indexof 2

Created: one year ago by: Guest

Jump to the latest result

indexof

for

indexof 2

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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