Benchmark: Math.max() vs sort()

Script Preparation code:

var values = new Array(5000);

for (let i = 0; i < values.length; ++i) {
    values[i] = i % 20;
}

Tests:

Math.max
return Math.max(...values);
sort
return values.sort((a, b) => b - a)[0]

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Math.max
sort

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36

Browser/OS: Chrome 137 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Math.max	269573.0 Ops/sec
sort	34318.4 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated one year ago):

LLMs can make mistakes. Check important info.

In this benchmark, the performance of two different JavaScript approaches to finding the maximum value in an array is compared: the use of `Math.max` and sorting the array with the `.sort()` method. Here’s a detailed breakdown of what is tested, the pros and cons of each approach, and other considerations.

### Tested Approaches

**1. `Math.max(...values)`**
   - **Definition**: This approach uses the `Math.max` function along with the spread operator to find the maximum value in an array called `values`.
   - **Test Name**: Math.max

**2. `values.sort((a, b) => b - a)[0]`**
   - **Definition**: This approach sorts the `values` array in descending order and retrieves the first element, which is the maximum value.
   - **Test Name**: sort

### Pros and Cons

#### `Math.max`
**Pros**:
- **Simplicity and Clarity**: The code is concise and easy to understand. It directly expresses the intent of getting the maximum value from the array.
- **Performance**: Typically more efficient for this specific operation as it does not involve sorting the entire array, resulting in better execution times in many cases.

**Cons**:
- **Array Size Limitations**: The use of the spread operator can lead to a stack overflow error if the array is too large (the maximum number of arguments to `Math.max` is limited by the JavaScript engine).

#### `values.sort()`
**Pros**:
- **Versatility**: The sorting method can be adapted for more complex sorting scenarios (not just finding the maximum).
  
**Cons**:
- **Performance Overhead**: The sort operation has a time complexity of O(n log n), which is generally slower than finding the maximum value which can be done in O(n) time for unsorted data.
- **Mutation**: Sorting the array modifies the original array if it is not copied before sorting, which might not always be desirable.

### Other Considerations
- **Input Data**: The benchmark prepares an array of 5000 elements, where each element is repeated in a pattern (0-19). This means the maximum is likely to be known (19), but the benchmark aims to provide a controlled scenario to test performance.
  
- **Execution Environment**: The benchmark results are recorded under the same system conditions (on a desktop machine using Chrome 132), which adds to the reliability of comparing the two methods.

### Alternatives
- **Using a Simple Loop**: Instead of using `Math.max` or sorting, a simple loop could be employed to iterate through the array and track the maximum, providing potentially clearer control over the process.
- **Functional Techniques**: Other functional programming methods such as `.reduce()` could also be considered for finding the maximum value in a more expressive way, though they may incur performance costs similar to `Math.max`.

### Conclusion
In this benchmark, the `Math.max` function significantly outperforms the sorting method in terms of execution speed, as shown by the results where `Math.max` executes approximately 6.66 times faster than using `sort()` to find the maximum. For finding the maximum value in a large dataset, `Math.max` is the preferable solution, assuming the array length falls within acceptable limits for the spread operator.

Related benchmarks:

Math.max() vs sort() (version: 1)

Compare speed of Math.max() vs sort.

Comparing performance of: Math.max vs sort

Created: one year ago by: Guest

Jump to the latest result

Math.max

sort

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one year ago):