Benchmark: Math.max() vs Array.reduce() vs For-loop

Script Preparation code:

var values = new Array(5000);

for (let i = 0; i < values.length; ++i) {
    values[i] = i % 20;
}

Tests:

Math.max
return Math.max(...values);
Reduce
return values.reduce((prev, curr) => { if (curr > prev) return curr; return prev; }, 0);
For-loop
let max = -Infinity; for (let v of values) { if (v > max) { max = v; } } return max;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Math.max
Reduce
For-loop

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) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36

Browser/OS: Chrome 108 on Windows

View result in a separate tab

Test name	Executions per second
Math.max	55330.0 Ops/sec
Reduce	94220.1 Ops/sec
For-loop	58952.8 Ops/sec

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

LLMs can make mistakes. Check important info.

**Overview of the Benchmark**

The provided JSON represents a benchmark test on MeasureThat.net, which compares the speed of three different approaches to find the maximum value in an array:

1. `Math.max()`
2. `Array.reduce()`
3. For-loop (manual iteration)

The test creates an array of 5000 elements and populates it with random values from 0 to 19.

**Options Compared**

* **`Math.max()`**: This method takes multiple arguments and returns the largest value among them.
	+ Pros: Concise, easy to read, and well-documented.
	+ Cons: May be slower due to function call overhead and potential caching issues.
* **`Array.reduce()`**: This method applies a callback function to each element of the array, reducing it to a single output value (the maximum in this case).
	+ Pros: Efficient for large datasets, allows for custom logic, and can be vectorized (i.e., applied to entire arrays at once).
	+ Cons: May require more setup and understanding of the callback function.
* **For-loop**: A traditional manual iteration using a loop to find the maximum value.
	+ Pros: Easy to understand, no external dependencies required, and can be optimized for specific use cases.
	+ Cons: Can be slow for large datasets due to the overhead of loop control and variable access.

**Library Usage**

* None mentioned in this benchmark.

**Special JS Features/Syntax**

None explicitly mentioned or used in this benchmark.

**Other Alternatives**

Additional approaches that could be considered for comparison:

1. **`Math.max.apply()`**: A more efficient variant of `Math.max()` that allows direct application to an array.
2. **`Array.prototype.map()` and `Array.prototype.reduce()`**: These methods can also be used to find the maximum value, although with slightly different syntax and potential performance characteristics.
3. **Native Web Workers**: For very large datasets, using web workers could distribute the computation across multiple threads or cores for significant speedups.

In summary, this benchmark provides a straightforward comparison of three well-known approaches to finding the maximum value in an array, highlighting the trade-offs between conciseness, efficiency, and customizability.

Related benchmarks:

Math.max() vs Array.reduce() vs For-loop (version: 0)

Compare speed of Math.max() vs Array.reduce().

Comparing performance of: Math.max vs Reduce vs For-loop

Created: 2 years ago by: Guest

Jump to the latest result

Math.max

Reduce

For-loop

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