Benchmark: find faster - for vs find vs map vs foreach

Script Preparation code:

var arr = []
let i = 0
let len = 1000
for(;i<len;i++) {
	arr.push(i)                
}

Tests:

for
let i = 0 let len = arr.length let foundIndex = -1 for(;i<len;i++) { if (arr[i] > 999){ return i } }
prototype.find
const found = arr.find(function(element) { return element > 999 })
forEach
let foundForEachIndex = -1 arr.forEach(function (item){ if (item[i] > 999){ foundForEachIndex = i return } })
map
let foundMapIndex = arr.map(item => { if (item[i] > 999){ return i } })

Historical Performance Data aggregated from 105 community runs

Desktop Results:

Chrome 78 runs

prototype.find

2.2M/s

for

33K/s

forEach

32K/s

map

29K/s

Fastest: prototype.find (74.7x faster)

View exact numbers

✓ prototype.find: 2,197,902 ops/sec
• for: 32,575 ops/sec
• forEach: 32,207 ops/sec
• map: 29,404 ops/sec

Firefox 12 runs

for

883K/s

prototype.find

242K/s

forEach

11K/s

map

10K/s

Fastest: for (86.9x faster)

View exact numbers

✓ for: 883,450 ops/sec
• prototype.find: 241,717 ops/sec
• forEach: 10,812 ops/sec
• map: 10,169 ops/sec

Safari 6 runs

prototype.find

1.4M/s

for

37K/s

map

19K/s

forEach

14K/s

Fastest: prototype.find (102.8x faster)

View exact numbers

✓ prototype.find: 1,388,782 ops/sec
• for: 37,255 ops/sec
• map: 19,230 ops/sec
• forEach: 13,511 ops/sec

Mobile Results:

Chrome 9 runs

prototype.find

1.5M/s

forEach

22K/s

for

18K/s

map

11K/s

Fastest: prototype.find (131.7x faster)

View exact numbers

✓ prototype.find: 1,452,636 ops/sec
• forEach: 21,947 ops/sec
• for: 17,686 ops/sec
• map: 11,032 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
for
prototype.find
forEach
map

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36

Browser/OS: Chrome 147 on Windows

View result in a separate tab

prototype.find

4.0M/s

for

978K/s

forEach

37K/s

map

33K/s

View exact numbers

Test name	Executions per second
✓ prototype.find	3,967,278 Ops/sec
for	977,564 Ops/sec
forEach	37,143 Ops/sec
map	32,786 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested, compared options, pros and cons, and other considerations.

**Benchmark Overview**

The test aims to find the fastest way to search for an element in an array that exceeds 999 using different approaches: `for`, `prototype.find`, `forEach`, and `map`.

**Options Compared**

1. **For Loop**: Iterates through the array manually using a counter variable (`i`) and checks each element individually.
2. **Prototype.find Method**: Uses the `find()` method, which calls the provided callback function once for each element in the array until it finds a match or reaches the end of the array.
3. **ForEach Loop**: Iterates through the array manually using an iterator (`forEach`) and executes a callback function for each element.
4. **Map Function**: Creates a new array with the results of applying a provided function to each element in the original array.

**Pros and Cons**

*   **For Loop**:
    *   Pros: Simple, efficient, and suitable for small arrays.
    *   Cons: Can be slow for large arrays due to manual iteration.
*   **Prototype.find Method**:
    *   Pros: Fast, concise, and elegant. Stops iterating as soon as a match is found.
    *   Cons: May not work well with older browsers or systems that don't support the `find()` method.
*   **ForEach Loop**:
    *   Pros: Easy to use, suitable for small to medium-sized arrays.
    *   Cons: Can be slower than `prototype.find` due to unnecessary iterations.
*   **Map Function**:
    *   Pros: Fast, suitable for large arrays. Returns a new array without modifying the original.
    *   Cons: Creates an additional array, which may not be necessary if only searching.

**Library and Special Features**

The test uses the `find()` method on prototype objects, which is a built-in feature of JavaScript. It's available in modern browsers and Node.js environments.

The `forEach` function also comes with JavaScript by default.

All these options are suitable for most use cases, but understanding their trade-offs can help optimize performance-critical code.

**Other Alternatives**

For similar searching scenarios:

1.  **Array.prototype.findIndex()**: Similar to `prototype.find`, but returns the index of the first element that satisfies the condition instead of the element itself.
2.  **Binary Search**: Suitable for sorted arrays, offering a significant improvement in performance over linear search algorithms.

**Code Explanation**

The provided benchmark code uses an array of 1000 elements and pushes numbers from 0 to 999 into it. Each test case uses a different method to find the index of the first element greater than 999:

1.  **For Loop**: Iterates manually using `i`, checks each element, and returns the index once found.
2.  **Prototype.find Method**: Uses the `find()` method to search for an element that satisfies the condition (`arr[i] > 999`).
3.  **ForEach Loop**: Iterates using `forEach`, executes a callback function for each element, and updates a variable if it finds an element greater than 999.
4.  **Map Function**: Creates a new array with results of applying a provided function to each element, stopping as soon as it finds an element that satisfies the condition.

These different methods highlight their performance differences in finding specific elements within large arrays.

**Benchmarking Considerations**

*   The test runs on Chrome 130 with multiple executions per second.
*   Devices are set as Desktop and Windows for consistency.
*   Browser and device information help when interpreting the benchmark results.

find faster - for vs find vs map vs foreach (version: 0)

Comparing performance of: `for vs prototype.find vs forEach vs map`

Created: 6 years ago by: Guest

Go to the latest result

for

prototype.find

forEach

map

Historical Performance Data aggregated from 105 community runs

Desktop Results:

Chrome 78 runs

Firefox 12 runs

Safari 6 runs

Mobile Results:

Chrome 9 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

find faster - for vs find vs map vs foreach (version: 0)

Comparing performance of: for vs prototype.find vs forEach vs map

Created: 6 years ago by: Guest

Go to the latest result

for

prototype.find

forEach

map

Historical Performance Data aggregated from 105 community runs

Desktop Results:

Chrome 78 runs

Firefox 12 runs

Safari 6 runs

Mobile Results:

Chrome 9 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `for vs prototype.find vs forEach vs map`