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: one year ago by: Guest

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

Tests:

Math.max.apply
max = Math.max.apply(Math, arr);
Math.max with spread
max = Math.max(...arr);
basic for loop
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 loop reverse
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; } }
Math.max.apply extracted into separate function
mathMax(arr)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

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: one year 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

Math.max.apply extracted into separate function

4.6M/s

Math.max.apply

417K/s

Math.max with spread

72K/s

for-of loop

6K/s

for loop length caching

4K/s

for loop reverse

3K/s

basic for loop

2K/s

View exact numbers

Test name	Executions per second
✓ Math.max.apply extracted into separate function	4,621,156 Ops/sec
Math.max.apply	416,660 Ops/sec
Math.max with spread	71,629 Ops/sec
for-of loop	6,471 Ops/sec
for loop length caching	3,547 Ops/sec
for loop reverse	3,447 Ops/sec
basic for loop	2,322 Ops/sec

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

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.