Benchmark: array math.max vs for loop variants

array math.max vs for loop 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, & finally a for-of loop

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

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

​x
 
var arr = [];var max = -Infinity;for (i = 0; i < 4096; i++) {   arr.push(Math.random() * 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;  }}

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

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:134.0) Gecko/20100101 Firefox/134.0

Browser/OS: Firefox 134 on Windows

View result in a separate tab

Test name	Executions per second
Math.max.apply	52504.6 Ops/sec
Math.max with spread	52354.1 Ops/sec
basic for loop	144585.6 Ops/sec
for loop length caching	155074.0 Ops/sec
for loop reverse	144456.4 Ops/sec
for-of loop	21305.4 Ops/sec

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

Let's break down the benchmark and its test cases.

Benchmark Description

The benchmark compares the performance of different ways to find the maximum value in an array:

Using Math.max.apply(Math, arr)
Using the spread operator (...arr)
A basic for loop with an if statement
A basic for loop with length caching (to avoid re-accessing arr.length on each iteration)
A reversed iterate basic loop
A for-of loop

Pros and Cons of Different Approaches

Math.max.apply(Math, arr):
- Pros: concise and readable
- Cons: may be slower due to the overhead of applying a function to an array
Math.max(...arr) (using spread operator):
- Pros: similar performance to Math.max.apply, but more concise and modern-looking
- Cons: requires JavaScript 2015 or later syntax
Basic for loop with if statement:
- Pros: simple and familiar, no additional dependencies required
- Cons: may be slower due to the overhead of repeated array lookups and comparisons
Basic for loop with length caching:
- Pros: can improve performance by avoiding repeated arr.length lookups
- Cons: slightly more complex code, requires understanding of how caching works
Reversed iterate basic loop:
- Pros: can be optimized for specific use cases (e.g., finding the maximum value in a sorted array)
- Cons: may be slower or less readable than other approaches due to the need to reverse the iteration order
For-of loop:
- Pros: modern and concise, allows for iterating over arrays without indexing
- Cons: may not be familiar to all developers, may have performance overhead due to the iterator object creation

Library Usage

None of the test cases use external libraries.

Special JavaScript Features or Syntax

Spread operator (...arr): used in tests 2 and 3 to pass an array as individual arguments to Math.max.
For-of loop: used in test case 6, which provides a concise way to iterate over arrays without indexing.
Length caching: used in test case 4, where the value of arr.length is stored in a variable (len) and reused on each iteration.

Alternatives

If you wanted to write this benchmark using a different language or framework, some alternatives could be:

Using Python with its built-in max function and list comprehensions
Using C++ with its standard library and iterator classes
Using Java with its Collections.max method and enhanced for loops

However, JavaScript is well-suited for this benchmark due to its dynamic nature, ease of use, and wide adoption.

LLMs can make mistakes. Check important info.

Let's break down the benchmark and its test cases.

**Benchmark Description**

The benchmark compares the performance of different ways to find the maximum value in an array:

1. Using `Math.max.apply(Math, arr)`
2. Using the spread operator (`...arr`)
3. A basic for loop with an if statement
4. A basic for loop with length caching (to avoid re-accessing `arr.length` on each iteration)
5. A reversed iterate basic loop
6. A for-of loop

**Pros and Cons of Different Approaches**

1. **Math.max.apply(Math, arr)**:
	* Pros: concise and readable
	* Cons: may be slower due to the overhead of applying a function to an array
2. **Math.max(...arr)** (using spread operator):
	* Pros: similar performance to `Math.max.apply`, but more concise and modern-looking
	* Cons: requires JavaScript 2015 or later syntax
3. **Basic for loop with if statement**:
	* Pros: simple and familiar, no additional dependencies required
	* Cons: may be slower due to the overhead of repeated array lookups and comparisons
4. **Basic for loop with length caching**:
	* Pros: can improve performance by avoiding repeated `arr.length` lookups
	* Cons: slightly more complex code, requires understanding of how caching works
5. **Reversed iterate basic loop**:
	* Pros: can be optimized for specific use cases (e.g., finding the maximum value in a sorted array)
	* Cons: may be slower or less readable than other approaches due to the need to reverse the iteration order
6. **For-of loop**:
	* Pros: modern and concise, allows for iterating over arrays without indexing
	* Cons: may not be familiar to all developers, may have performance overhead due to the iterator object creation

**Library Usage**

None of the test cases use external libraries.

**Special JavaScript Features or Syntax**

1. **Spread operator (`...arr`)**: used in tests 2 and 3 to pass an array as individual arguments to `Math.max`.
2. **For-of loop**: used in test case 6, which provides a concise way to iterate over arrays without indexing.
3. **Length caching**: used in test case 4, where the value of `arr.length` is stored in a variable (`len`) and reused on each iteration.

**Alternatives**

If you wanted to write this benchmark using a different language or framework, some alternatives could be:

* Using Python with its built-in `max` function and list comprehensions
* Using C++ with its standard library and iterator classes
* Using Java with its `Collections.max` method and enhanced for loops

However, JavaScript is well-suited for this benchmark due to its dynamic nature, ease of use, and wide adoption.

Related benchmarks: