Benchmark: Get max from an array of numbers (Math.max vs. iteration) V2

Script Preparation code:

var arr = [...Array(10000)].map(() => Math.floor(Math.random() * 100000));

Tests:

Math.max
return Math.max(...arr);
Find
return arr.reduce((maxi, curr) => maxi < curr ? curr : maxi, -1);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Math.max
Find

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 years ago)

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

Browser/OS: Chrome 104 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Math.max	67815.8 Ops/sec
Find	71477.1 Ops/sec

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

LLMs can make mistakes. Check important info.

I'd be happy to help you understand the benchmark.

**What is being tested?**

The benchmark tests two approaches for finding the maximum value in an array of numbers: using the built-in `Math.max()` function versus implementing it manually by iterating over the array.

**Options compared:**

1. **`Math.max()`**: This is a built-in JavaScript function that returns the largest of zero or more numbers.
2. **Manual implementation using iteration**: In this approach, you would iterate over the array, comparing each element to keep track of the maximum value.

**Pros and Cons:**

*   **`Math.max()`**:
    *   Pros:
        +   Fast and efficient, as it is implemented in native code.
        +   Less error-prone, as it handles edge cases like empty arrays or zero values automatically.
    *   Cons:
        +   Requires the array to have at least one element to be valid.
*   **Manual implementation using iteration**:
    *   Pros:
        +   Can handle arrays of any size, including empty ones.
        +   Allows for customization and optimization based on specific use cases.
    *   Cons:
        +   Slower and less efficient compared to `Math.max()`.
        +   More error-prone, as you need to ensure the comparison logic is correct.

**Library usage:**

None of the provided code uses any external libraries.

**Special JavaScript feature or syntax:**

There are no special features or syntaxes used in this benchmark. It only focuses on comparing two basic approaches for finding the maximum value in an array.

**Other alternatives:**

If you need to find the maximum value in a large dataset, other approaches could include:

*   Using `Array.prototype.reduce()`: Similar to manual iteration but with a more concise syntax.
*   Utilizing parallel processing or multi-threading: This can significantly improve performance on modern CPUs by leveraging multiple cores.
*   Leveraging specialized libraries like NumJS or ArrayFire for optimized array operations.

In conclusion, the benchmark provides a straightforward comparison between two approaches for finding the maximum value in an array. Understanding the trade-offs and pros and cons of each approach will help you choose the most suitable method depending on your specific use case requirements.

Related benchmarks:

Get max from an array of numbers (Math.max vs. iteration) V2 (version: 0)

Comparing performance of: Math.max vs Find

Created: 2 years ago by: Guest

Jump to the latest result

Math.max

Find

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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