Benchmark: Find in array - 002

Script Preparation code:

var size = 10000
var arr = []
for (let i = 0; i < size; i++) {
    arr.push(i)
}
var research = 6578;

Tests:

For i++ (const size)
const a_size = arr.length; var index = -1; for (let y = 0; y < a_size; y++) { if (research === arr[y]) { index = y; break; } }
For i++ (.length)
var index = -1; for (let y = 0; y < arr.length; y++) { if (research === arr[y]) { index = y; break; } }
For ... in
var index = -1; for (const y in arr) { if (research === arr[y]) { index = y; break; } }
for ... of
var index = -1; for (const el of arr) { if (research === el) { index = el; break; } }
indexOf
var index = arr.indexOf(research)
findIndex
var index = arr.findIndex(e => e === research)
Includes
var found = arr.includes(research)
Some ?
var found = arr.some(e => e === research)
forEach
var index = -1; arr.forEach((el, y) => { if (research === el) { index = y; return; } })

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
For i++ (const size)
For i++ (.length)
For ... in
for ... of
indexOf
findIndex
Includes
Some ?
forEach

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:105.0) Gecko/20100101 Firefox/105.0

Browser/OS: Firefox 105 on Windows

View result in a separate tab

Test name	Executions per second
For i++ (const size)	201063.5 Ops/sec
For i++ (.length)	198844.5 Ops/sec
For ... in	718.1 Ops/sec
for ... of	12364.1 Ops/sec
indexOf	236898.1 Ops/sec
findIndex	32259.1 Ops/sec
Includes	236380.7 Ops/sec
Some ?	33754.7 Ops/sec
forEach	23068.8 Ops/sec

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

LLMs can make mistakes. Check important info.

Measuring the performance of various JavaScript loops and array methods is crucial for optimizing code efficiency.

**Benchmark Overview**

The provided benchmark tests six different ways to find an element in an array:

1. For loop with indexing (`for (let i = 0; i < size; i++) { ... }`)
2. For loop with `length` property (`for (let y = 0; y < arr.length; y++) { ... }`)
3. For...in loop (`for (const y in arr) { ... }`)
4. For-each loop with iteration (`for (el of arr) { ... }`)
5. Array method `indexOf()`
6. Array method `findIndex()`

**Comparison of Loops**

*   **For i++ (const size)**: This loop uses a traditional for loop with indexing, but avoids the incrementing issue by using `arr.length` as the condition.
*   **For i++ (.length)**: Similar to the first option, this loop also uses a for loop with indexing and `length` property. However, it does not avoid the incrementing issue.
*   **For ... in**: This loop uses the for...in loop, which iterates over the array's property names (i.e., indices). It is less efficient than traditional loops or array methods.
*   **for ... of**: This loop uses the new `for...of` loop syntax, which iterates over an array's elements. It is generally more readable and efficient than traditional for loops.

**Array Method Performance**

The benchmark also tests six different array methods:

1. `indexOf()`
2. `findIndex()`
3. `includes()`
4. `some()`
5. Array method `forEach()`

These array methods are designed to provide a convenient way to work with arrays, but they can be less efficient than traditional loops in certain situations.

**Performance Pros and Cons**

| Method | Pros | Cons |
| --- | --- | --- |
| For i++ (const size) | Avoids incrementing issue | May have slower performance due to unnecessary iteration |
| For i++ (.length) | Easy to implement, avoids incrementing issue | Still has a potential for slower performance due to indexing calculations |
| For ... in | Iterates over property names, less memory usage | Less efficient than traditional loops or array methods |
| for ... of | More readable and modern syntax, generally more efficient | May not be suitable for older browsers or environments that don't support it |
| Array method `indexOf()` | Convenient and easy to use, but may have slower performance due to iteration over the entire array | Can return -1 if element is not found |
| Array method `findIndex()` | Similar to `indexOf()`, but returns the index of the first occurrence | May have slower performance due to iteration over the entire array |
| Array method `includes()` | Fast and efficient, suitable for most use cases | May be less readable than other methods |
| Array method `some()` | Convenient and easy to use, suitable for checking if any element matches a condition | Can return false if no elements match the condition |
| Array method `forEach()` | Suitable for iterating over arrays, but can be slower due to unnecessary iteration | May not be suitable for older browsers or environments that don't support it |

**Performance Results**

The provided benchmark results show the performance of each loop and array method. The results indicate that:

*   For loops with indexing (`for (let i = 0; i < size; i++)`) are generally faster than traditional for loops.
*   Array methods `indexOf()` and `findIndex()` have slower performance due to iteration over the entire array, but may be more convenient to use in certain situations.
*   The new `for...of` loop syntax is generally more efficient than traditional for loops.

**Best Practices**

Based on the benchmark results, here are some best practices for optimizing JavaScript code:

*   Use traditional for loops with indexing instead of incrementing variables when iterating over arrays.
*   Avoid using array methods like `indexOf()` and `findIndex()` unless necessary, as they can be slower than traditional loops.
*   Choose the most efficient loop or array method based on your specific use case and performance requirements.

Overall, understanding the pros and cons of different JavaScript loops and array methods is crucial for optimizing code efficiency and writing high-performance applications.

Related benchmarks:

Find in array - 002 (version: 1)

Comparing performance of: For i++ (const size) vs For i++ (.length) vs For ... in vs for ... of vs indexOf vs findIndex vs Includes vs Some ? vs forEach

Created: 2 years ago by: Registered User

Jump to the latest result

For i++ (const size)

For i++ (.length)

For ... in

for ... of

indexOf

findIndex

Includes

Some ?

forEach

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