Toggle navigation
MeasureThat
.net
Create a benchmark
Tools
Feedback
FAQ
Register
Log In
array.indexof vs for
(version: 0)
Comparing performance of:
indexof vs for vs indexof 2
Created:
2 years ago
by:
Guest
Go to the latest result
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>
Run tests (3)
Previous results
Fork
Test case name
Result
indexof
for
indexof 2
Fastest:
N/A
Slowest:
N/A
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/126.0.0.0 Safari/537.36
Browser/OS:
Chrome 126 on Mac OS X 10.15.7
View result in a separate tab
Embed
Embed Benchmark Result
<iframe src="https://measurethat.net/Embed?id=532553" width="100%" height="500px"></iframe>
indexof 2
3.2M/s
indexof
2.6M/s
for
16K/s
View exact numbers
Test name
Executions per second
✓
indexof 2
3,185,848 Ops/sec
indexof
2,602,813 Ops/sec
for
15,828 Ops/sec
Autogenerated LLM Summary
(model
llama3.2:3b
, generated one year ago):
**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 fill method vs for loop
TypedArray fill vs loop
Array fill map, vs for i loop
Array.from() vs new Array() vs push
Comments
Confirm delete:
Do you really want to delete benchmark?