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

array math.max (3 variants) vs for loop (4 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

Created: 5 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);
}

​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);}

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
mathMax(arr)
mathMax(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

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/129.0.0.0 Safari/537.36

Browser/OS: Chrome 129 on Windows

View result in a separate tab

Test name	Executions per second
Math.max.apply	416659.7 Ops/sec
Math.max with spread	71629.2 Ops/sec
basic for loop	2321.8 Ops/sec
for loop length caching	3547.4 Ops/sec
for loop reverse	3446.5 Ops/sec
for-of loop	6471.1 Ops/sec
Math.max.apply extracted into separate function	4621156.0 Ops/sec

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

I'll provide an explanation of the benchmark, options compared, pros and cons, and other considerations.

Benchmark Overview

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

Math.max.apply with .apply
Math.max with spread operator (...)
Basic for loop with an if statement
Basic for loop with length caching
For loop that iterates from the end of the array
For-of loop
Extracted Math.max.apply function

Options Compared

The benchmark compares seven different approaches:

Math.max.apply with .apply
Math.max with spread operator (...)
Basic for loop with an if statement
Basic for loop with length caching
For loop that iterates from the end of the array
For-of loop
Extracted Math.max.apply function

Pros and Cons

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

Math.max.apply with .apply:
- Pros: Simple, readable, and well-documented.
- Cons: Uses the apply method, which can be slower than other approaches.
Math.max with spread operator (...):
- Pros: Modern syntax, fast, and easy to read.
- Cons: Requires modern JavaScript engines (not supported in older browsers).
Basic for loop with an if statement:
- Pros: Simple, well-documented, and works everywhere.
- Cons: Can be slower than other approaches due to the overhead of if statements.
Basic for loop with length caching:
- Pros: Caches the array length, reducing the number of calls to length.
- Cons: May not be as readable or maintainable as other approaches.
For loop that iterates from the end of the array:
- Pros: Can be faster than traditional for loops due to less overhead.
- Cons: Less readable and maintainable than other approaches.
For-of loop:
- Pros: Modern syntax, fast, and easy to read.
- Cons: Not supported in older browsers or environments.
Extracted Math.max.apply function:
- Pros: Can be more readable and maintainable than the original implementation.
- Cons: Requires extra function creation and overhead.

Other Considerations

The benchmark also takes into account the following:

Array size: The benchmark uses an array of 4096 elements, which can affect performance.
JavaScript version: The benchmark uses modern JavaScript engines (Chrome 129), which may not support all features or approaches.
Browser environment: The benchmark runs on a desktop browser (Chrome 129) and Windows operating system.

Alternatives

If you're interested in exploring alternative approaches, consider the following:

Using Array.prototype.reduce() instead of loops to find the maximum value.
Implementing a custom binary search algorithm to find the maximum value.
Using parallel processing or multi-threading to speed up the benchmark.

Keep in mind that these alternatives may not be as readable or maintainable as the approaches compared in the benchmark.

LLMs can make mistakes. Check important info.

I'll provide an explanation of the benchmark, options compared, pros and cons, and other considerations.

**Benchmark Overview**

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

1. `Math.max.apply` with `.apply`
2. `Math.max` with spread operator (`...`)
3. Basic for loop with an if statement
4. Basic for loop with length caching
5. For loop that iterates from the end of the array
6. For-of loop
7. Extracted `Math.max.apply` function

**Options Compared**

The benchmark compares seven different approaches:

* `Math.max.apply` with `.apply`
* `Math.max` with spread operator (`...`)
* Basic for loop with an if statement
* Basic for loop with length caching
* For loop that iterates from the end of the array
* For-of loop
* Extracted `Math.max.apply` function

**Pros and Cons**

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

1. `Math.max.apply` with `.apply`:
	* Pros: Simple, readable, and well-documented.
	* Cons: Uses the `apply` method, which can be slower than other approaches.
2. `Math.max` with spread operator (`...`):
	* Pros: Modern syntax, fast, and easy to read.
	* Cons: Requires modern JavaScript engines (not supported in older browsers).
3. Basic for loop with an if statement:
	* Pros: Simple, well-documented, and works everywhere.
	* Cons: Can be slower than other approaches due to the overhead of `if` statements.
4. Basic for loop with length caching:
	* Pros: Caches the array length, reducing the number of calls to `length`.
	* Cons: May not be as readable or maintainable as other approaches.
5. For loop that iterates from the end of the array:
	* Pros: Can be faster than traditional for loops due to less overhead.
	* Cons: Less readable and maintainable than other approaches.
6. For-of loop:
	* Pros: Modern syntax, fast, and easy to read.
	* Cons: Not supported in older browsers or environments.
7. Extracted `Math.max.apply` function:
	* Pros: Can be more readable and maintainable than the original implementation.
	* Cons: Requires extra function creation and overhead.

**Other Considerations**

The benchmark also takes into account the following:

* Array size: The benchmark uses an array of 4096 elements, which can affect performance.
* JavaScript version: The benchmark uses modern JavaScript engines (Chrome 129), which may not support all features or approaches.
* Browser environment: The benchmark runs on a desktop browser (Chrome 129) and Windows operating system.

**Alternatives**

If you're interested in exploring alternative approaches, consider the following:

* Using `Array.prototype.reduce()` instead of loops to find the maximum value.
* Implementing a custom binary search algorithm to find the maximum value.
* Using parallel processing or multi-threading to speed up the benchmark.

Keep in mind that these alternatives may not be as readable or maintainable as the approaches compared in the benchmark.

Related benchmarks: