Benchmark: array math.max (3 variants) vs for loop (5 variants)

array math.max (3 variants) vs for loop (5 variants) (version: 0)

compare finding the maximum value with Math.max using .apply & using the spread (...) operator, vs a basic for loop with an if statement, a basic foor loop using length caching, a reversed iterate basic loop, a for-of loop, & finally a a Math.max.apply helper function.

Comparing performance of: Math.max.apply vs Math.max with spread vs basic for loop vs for loop length caching vs for loop reverse vs for-of loop vs Math.max.apply extracted into separate function vs for loop length caching extracted into separate function

Created: 6 months ago by: Guest

Jump to the latest result

Script Preparation code:

var arr = [];
var max = -Infinity;
for (i = 0; i < 4096; i++) { 
  arr.push(Math.random() * i);
}

function mathMax (array) {
	return Math.max.apply(Math, array);
}

function forLoop (array) {
	for (let i = 0, len = arr.length; i < len; i++) {
  		if (arr[i] > max) {
    		max = arr[i];
  		}
	}
}

​x
 
var arr = [];var max = -Infinity;for (i = 0; i < 4096; i++) {   arr.push(Math.random() * i);}​function mathMax (array) {    return Math.max.apply(Math, array);}​function forLoop (array) {    for (let i = 0, len = arr.length; i < len; i++) {        if (arr[i] > max) {            max = arr[i];        }    }}

Tests:

Math.max.apply
max = Math.max.apply(Math, arr);
max = Math.max.apply(Math, arr);
Math.max with spread
max = Math.max(...arr);
max = Math.max(...arr);

basic for loop

for (let i = 0; i < arr.length; i++) {
  if (arr[i] > max) {
    max = arr[i];
  }
}

 
for (let i = 0; i < arr.length; i++) {  if (arr[i] > max) {    max = arr[i];  }}

for loop length caching

for (let i = 0, len = arr.length; i < len; i++) {
  if (arr[i] > max) {
    max = arr[i];
  }
}

 
for (let i = 0, len = arr.length; i < len; i++) {  if (arr[i] > max) {    max = arr[i];  }}​

for loop reverse

for (let i = arr.length - 1; i >= 0; i--) {
  if (arr[i] > max) {
    max = arr[i];
  }
}

 
for (let i = arr.length - 1; i >= 0; i--) {  if (arr[i] > max) {    max = arr[i];  }}

for-of loop

for (const value of arr) {
  if (value > max) {
    max = value;
  }
}

 
for (const value of arr) {  if (value > max) {    max = value;  }}

Math.max.apply extracted into separate function
max = mathMax(arr)
max = mathMax(arr)
for loop length caching extracted into separate function
max = forLoop(arr)
max = forLoop(arr)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
Math.max.apply
Math.max with spread
basic for loop
for loop length caching
for loop reverse
for-of loop
Math.max.apply extracted into separate function
for loop length caching extracted into separate function

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 5 months ago)

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

Browser/OS: Chrome 130 on Windows

View result in a separate tab

Test name	Executions per second
Math.max.apply	246742.0 Ops/sec
Math.max with spread	52866.6 Ops/sec
basic for loop	1674.5 Ops/sec
for loop length caching	2496.5 Ops/sec
for loop reverse	2499.1 Ops/sec
for-of loop	4625.6 Ops/sec
Math.max.apply extracted into separate function	269100.9 Ops/sec
for loop length caching extracted into separate function	2324.1 Ops/sec

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

I'll break down the benchmark and explain what's being tested, compared, and their pros and cons.

Benchmark Overview

The benchmark compares different approaches to find the maximum value in an array of numbers:

Math.max.apply with an array using .apply
Math.max with the spread operator (...)
A basic for loop with an if statement
A basic for loop with length caching
A reversed iterate basic loop
A for-of loop
An extracted Math.max.apply helper function
An extracted for loop length caching helper function

Library and Features

The benchmark uses the built-in JavaScript Math.max function.
No special JavaScript features or syntax are mentioned, but it's worth noting that some browsers may optimize certain functions.

Test Cases

Each test case has a unique implementation:

Math.max.apply: Uses Math.max.apply with an array using .apply.
Math.max with spread: Uses Math.max with the spread operator (...).
Basic for loop: Uses a basic for loop with an if statement.
For loop length caching: Uses a basic for loop with length caching to avoid re-computing the array length on each iteration.
Reversed iterate basic loop: Iterates over the array in reverse order using a while loop.
For-of loop: Uses a for-of loop, which is similar to a traditional for loop but uses iterators instead of indexes.
Math.max.apply extracted into separate function: Extracts the logic from Math.max.apply into a separate helper function.
For loop length caching extracted into separate function: Extracts the logic from the for loop with length caching into a separate helper function.

Comparison and Pros/Cons

The benchmark compares the performance of each approach on different hardware configurations. Here's a brief summary:

Math.max.apply and Math.max with spread are likely to be the fastest since they use optimized built-in functions.
The basic for loop is slower than the other methods, but can still provide good performance if implemented correctly.
For loop length caching can provide better performance by avoiding re-computing the array length on each iteration, but may require more code and understanding of how it works.
Reversed iterate basic loop and for-of loop are likely to be slower due to the overhead of using iterators or reversing the array.
The extracted helper functions can improve performance by breaking down complex logic into smaller, more manageable pieces.

Benchmark Results

The benchmark results show that Math.max.apply and Math.max with spread are consistently among the fastest, while the basic for loop and other approaches tend to be slower. However, the results also suggest that there may be some variation in performance depending on the specific hardware configuration.

In summary, this benchmark provides a useful comparison of different approaches to finding the maximum value in an array, highlighting the importance of optimizing built-in functions and breaking down complex logic into smaller pieces.

LLMs can make mistakes. Check important info.

I'll break down the benchmark and explain what's being tested, compared, and their pros and cons.

**Benchmark Overview**

The benchmark compares different approaches to find the maximum value in an array of numbers:

1. `Math.max.apply` with an array using `.apply`
2. `Math.max` with the spread operator (`...`)
3. A basic for loop with an if statement
4. A basic for loop with length caching
5. A reversed iterate basic loop
6. A for-of loop
7. An extracted `Math.max.apply` helper function
8. An extracted for loop length caching helper function

**Library and Features**

* The benchmark uses the built-in JavaScript `Math.max` function.
* No special JavaScript features or syntax are mentioned, but it's worth noting that some browsers may optimize certain functions.

**Test Cases**

Each test case has a unique implementation:

1. `Math.max.apply`: Uses `Math.max.apply` with an array using `.apply`.
2. `Math.max with spread`: Uses `Math.max` with the spread operator (`...`).
3. Basic for loop: Uses a basic for loop with an if statement.
4. For loop length caching: Uses a basic for loop with length caching to avoid re-computing the array length on each iteration.
5. Reversed iterate basic loop: Iterates over the array in reverse order using a while loop.
6. For-of loop: Uses a for-of loop, which is similar to a traditional for loop but uses iterators instead of indexes.
7. `Math.max.apply` extracted into separate function: Extracts the logic from `Math.max.apply` into a separate helper function.
8. For loop length caching extracted into separate function: Extracts the logic from the for loop with length caching into a separate helper function.

**Comparison and Pros/Cons**

The benchmark compares the performance of each approach on different hardware configurations. Here's a brief summary:

* `Math.max.apply` and `Math.max with spread` are likely to be the fastest since they use optimized built-in functions.
* The basic for loop is slower than the other methods, but can still provide good performance if implemented correctly.
* For loop length caching can provide better performance by avoiding re-computing the array length on each iteration, but may require more code and understanding of how it works.
* Reversed iterate basic loop and for-of loop are likely to be slower due to the overhead of using iterators or reversing the array.
* The extracted helper functions can improve performance by breaking down complex logic into smaller, more manageable pieces.

**Benchmark Results**

The benchmark results show that `Math.max.apply` and `Math.max with spread` are consistently among the fastest, while the basic for loop and other approaches tend to be slower. However, the results also suggest that there may be some variation in performance depending on the specific hardware configuration.

Related benchmarks: