Benchmark: Search - forEach vs reduce vs map vs filter vs for

Script Preparation code:

var arr = [];
for (var i = 0; i < 12345; i++) {
  arr[i] = i;
}
var result = [
[],[],[],[],[]
]

Tests:

forEach
arr.forEach(item => item == 12344 && result[0].push(item));
reduce
result[1] = arr.reduce((lastValue, item) => { if (item == 12344) return item; });
map
arr.map(item => (item == 12344 && result[2].push(item)));
filter
result[3] = arr.filter(item => (item == 12344));
for
for (var j = 0; j < arr.length; j++) { if(arr[i]==12344) result[4].push(arr[i]) }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
forEach
reduce
map
filter
for

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript benchmarks!

**Benchmark Overview**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks. The provided benchmark measures the execution time of five different approaches for searching an array: `forEach`, `reduce`, `map`, `filter`, and a simple `for` loop.

**Approaches Compared**

The five approaches compared in this benchmark are:

1. **`forEach`**: Iterates over the array using a callback function, checking if each element is equal to 12344.
2. **`reduce`**: Reduces the array to a single value by accumulating results with a callback function, checking if each element is equal to 12344.
3. **`map`**: Creates a new array with transformed elements using a callback function, checking if each element is equal to 12344.
4. **`filter`**: Creates a new array with filtered elements using a callback function, checking if each element is equal to 12344.
5. **Simple `for` loop**: Iterates over the array using an index variable, checking if each element is equal to 12344.

**Pros and Cons of Each Approach**

Here's a brief summary of the pros and cons of each approach:

1. **`forEach`**:
	* Pros: Easy to read and understand, doesn't require manual indexing.
	* Cons: Can be slower due to the overhead of function calls.
2. **`reduce`**:
	* Pros: Efficient for accumulation operations, can be faster than `forEach`.
	* Cons: Requires initial value, can be less readable if not used correctly.
3. **`map`**:
	* Pros: Creates a new array with transformed elements, doesn't modify the original array.
	* Cons: Can be slower due to function call overhead, creates a new array.
4. **`filter`**:
	* Pros: Efficient for creating filtered arrays, can be faster than `forEach`.
	* Cons: Requires an initial value and a callback function, can be less readable.
5. **Simple `for` loop**:
	* Pros: Fast and efficient, doesn't require any libraries or functions.
	* Cons: Can be error-prone if not implemented correctly, requires manual indexing.

**Library Usage**

None of the approaches use external libraries in this benchmark.

**Special JS Features/Syntax**

The benchmark uses several JavaScript features, including:

1. **Arrow functions**: Used for `forEach`, `map`, and `filter`.
2. **Callback functions**: Used for all five approaches.
3. **Array methods**: Used for `reduce`, `map`, and `filter`.

**Other Alternatives**

If you're looking for alternative approaches to search an array, consider the following:

1. **`some()`**: Similar to `filter`, but returns a boolean value instead of an array.
2. **`every()`**: Similar to `reduce`, but returns a boolean value instead of an array.
3. **Regular expressions**: Can be used for searching arrays, but may not be as efficient as the above methods.

Keep in mind that the choice of approach depends on the specific use case and requirements of your project.

Latest run results:

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

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 14_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.1.1 Mobile/15E148 Safari/604.1

Browser/OS: Mobile Safari 14 on iOS 14.6

View result in a separate tab

Test name	Executions per second
forEach	59408.0 Ops/sec
reduce	43501.3 Ops/sec
map	26754.9 Ops/sec
filter	28105.7 Ops/sec
for	385.4 Ops/sec

Related benchmarks:

Search - forEach vs reduce vs map vs filter vs for (version: 0)

Comparing performance of: forEach vs reduce vs map vs filter vs for

Created: 2 years ago by: Guest

Jump to the latest result

forEach

reduce

map

filter

for

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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