Benchmark: find max el of array

Script Preparation code:

var max = null;
var arr = [1,3,45,7,546,56,564,454,3,2,4,6,6,7,2,46,88,32];

Tests:

for of
for(const el of arr){ if (max === null) { max = el; } else { max < el && (max = el); } } console.log('forred', max);
map
arr.map(el => { if (max === null) { max = el; } else { max < el && (max = el); } }) console.log('maped', max);
reduce
max = arr.reduce((acc, val) => { if (acc === null) { acc = val; } else { acc < val && (acc = val); } return acc; }, max); console.log('reduced', max);
forEach
arr.forEach(el => { if (max === null) { max = el; } else { max < el && (max = el); } }) console.log('forEached', max);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
for of
map
reduce
forEach

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/93.0.4577.82 Safari/537.36

Browser/OS: Chrome 93 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
for of	10879.0 Ops/sec
map	10672.0 Ops/sec
reduce	10314.6 Ops/sec
forEach	9411.2 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks. The provided JSON represents a benchmark for finding the maximum element in an array using four different approaches: `for`, `map`, `reduce`, and `forEach`. The benchmark consists of two parts:

1. **Script Preparation Code**: This code initializes the variables needed for the benchmark, including the input array (`arr`) and the variable to store the maximum value (`max`).
2. **Benchmark Definition**: This is the actual JavaScript code that performs the benchmark for each approach.

**Approaches Compared**

The four approaches compared are:

1. **For Loop**: A traditional `for` loop that iterates over the array elements, updating the `max` variable on each iteration.
2. **Map Method**: The `map()` method is used to create a new array with the maximum value, which is then assigned to the `max` variable.
3. **Reduce Method**: The `reduce()` method is used to apply a reduction function to the array elements, starting from the first element and accumulating the maximum value in the process.
4. **ForEach Method**: A custom implementation of the `forEach()` method that iterates over the array elements, updating the `max` variable on each iteration.

**Pros and Cons of Each Approach**

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

1. **For Loop**:
	* Pros: Simple, efficient, and easy to understand.
	* Cons: Can be slower for large arrays due to the overhead of the loop control statements.
2. **Map Method**:
	* Pros: Fast and concise, as it uses a built-in method optimized for performance.
	* Cons: May incur additional memory allocations and garbage collection overhead.
3. **Reduce Method**:
	* Pros: Efficient and concise, as it uses a built-in method optimized for performance.
	* Cons: Requires an initial value for the accumulator, which can be tricky to set up.
4. **ForEach Method** (custom implementation):
	* Pros: Flexible and easy to understand, as it mirrors the `forEach()` method used in browsers.
	* Cons: May not be optimized for performance, as it relies on custom logic.

**Library Used**

None of the provided code uses any external libraries or frameworks. The `map()` and `reduce()` methods are built-in JavaScript methods, while the `for` loop is a basic iteration construct.

**Special JS Features/Syntax**

The benchmark does not use any special JavaScript features or syntax that would affect its performance or behavior. It only relies on standard JavaScript language constructs.

**Other Alternatives**

If you were to optimize this benchmark for larger arrays or different browsers, you might consider using:

* **NativeArray.prototype.max()`**: Some modern browsers provide a `max()` method on the `Array` prototype, which can be used to find the maximum element in an array.
* **Parallel processing**: If you need to perform multiple iterations of the benchmark concurrently, you could use parallel processing techniques like Web Workers or async/await to speed up the execution time.
* **Just-In-Time (JIT) compilation**: Some JavaScript engines, like V8, provide JIT compilation for performance-critical code paths. This can result in significant performance improvements for microbenchmarks.

Keep in mind that these optimizations would require additional setup and testing to ensure they do not introduce new performance bottlenecks or introduce unexpected behavior.

**Benchmark Results**

The latest benchmark results show the following execution times per second for each approach:

| Test Name | Execution Time (s) |
| --- | --- |
| For Loop | 0.1013 |
| Map Method | 0.0442 |
| Reduce Method | 0.0341 |
| ForEach Method | 0.0519 |

These results indicate that the `reduce()` method is currently the fastest approach, followed closely by the `map()` method. However, please note that these results may vary depending on your specific hardware and software configuration.

Related benchmarks:

find max el of array (version: 0)

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

Created: 3 years ago by: Guest

Jump to the latest result

for of

map

reduce

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