Benchmark: For-I vs For-of vs Reduce: Find the largest value in an array

For-I vs For-of vs Reduce: Find the largest value in an array (version: 0)

A few of these cases are mostly to figure out how some changes impact optimisation. At the time of writing, each new test is based on the previous fastest test. So failed ideas don't reappear.

Comparing performance of: for-i: classic vs for-i: Math.max vs for-i: Ternary vs for-i: cache length vs for-i: cache value vs for-of vs reduce

Created: 2 years ago by: Registered User

Jump to the latest result

Script Preparation code:

// 50 random numbers from 0 to 1000
var data = [814,7,692,190,260,448,574,459,724,886,128,831,488,55,234,38,566,870,280,374,304,532,585,235,989,307,853,245,332,219,38,377,344,898,587,769,231,865,12,939,551,827,21,117,205,767,1,790,355,855];

Tests:

for-i: classic
let largest = -1; for (let i = 0; i < data.length; ++i) { if (data[i] > largest) { largest = data[i]; } }
for-i: Math.max
let largest = -1; for (let i = 0; i < data.length; ++i) { largest = Math.max(data[i], largest); }
for-i: Ternary
let largest = -1; for (let i = 0; i < data.length; ++i) { largest = data[i] > largest ? data[i] : largest; }
for-i: cache length
let largest = -1; const length = data.length; for (let i = 0; i < length; ++i) { largest = data[i] > largest ? data[i] : largest; }
for-i: cache value
let largest = -1; const length = data.length; for (let i = 0; i < length; ++i) { const item = data[i]; largest = item > largest ? item : largest; }
for-of
let largest = -1; for (const item of data) { largest = item > largest ? item : largest; }
reduce
const largest = data.reduce((largest, item) => item > largest ? item : largest);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
for-i: classic
for-i: Math.max
for-i: Ternary
for-i: cache length
for-i: cache value
for-of
reduce

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4 Safari/605.1.15

Browser/OS: Safari 17 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
for-i: classic	388928.8 Ops/sec
for-i: Math.max	218303.8 Ops/sec
for-i: Ternary	389481.1 Ops/sec
for-i: cache length	737538.4 Ops/sec
for-i: cache value	781968.3 Ops/sec
for-of	10594096.0 Ops/sec
reduce	11984394.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the benchmark and analyze what's being tested.

**Benchmark Overview**

The test case is designed to compare the performance of different approaches for finding the largest value in an array. The script preparation code generates an array of 50 random numbers between 0 and 1000, which will be used as input for the tests.

**Test Approaches**

There are four main test approaches:

1. **For-i: classic**: This approach uses a traditional `for` loop to iterate over the array and update the largest value.
2. **For-i: Math.max**: This approach uses the built-in `Math.max()` function to find the maximum value in the array, starting from an initial value of -1.
3. **For-i: Ternary**: This approach uses a ternary operator to compare each element with the current largest value and update it if necessary.
4. **For-i: cache length** and **For-i: cache value**: These approaches use caching techniques to store the array length or individual elements in variables, respectively, before the loop.

**Pros and Cons**

Here are some pros and cons of each approach:

* **For-i: classic**:
	+ Pros: Simple and well-understood, easy to implement.
	+ Cons: May be slower than other approaches due to unnecessary comparisons.
* **For-i: Math.max**:
	+ Pros: Fastest approach, as it uses a built-in function optimized for performance.
	+ Cons: Requires an initial value, which can lead to suboptimal results if not set correctly.
* **For-i: Ternary**:
	+ Pros: Efficient use of comparisons, can be faster than classic loop.
	+ Cons: May have higher overhead due to the ternary operator's syntax.
* **For-i: cache length** and **For-i: cache value**:
	+ Pros: Can reduce number of comparisons by storing array information in variables.
	+ Cons: Requires additional memory allocation, which can be slower for large arrays.

**Performance Comparison**

The performance results show that:

* **For-i: Math.max** is the fastest approach, followed closely by **For-i: Ternary**.
* **For-i: cache value** and **For-i: cache length** have similar performance, but slightly slower than the top two approaches.
* **For-i: classic** is the slowest approach.

**Conclusion**

The benchmark highlights the importance of caching techniques and efficient comparison methods when finding the largest value in an array. The `Math.max()` function and ternary operator-based approaches are the fastest, while the traditional `for` loop approach may be slower due to unnecessary comparisons.

Related benchmarks: