Benchmark: Lodash max vs Math.max

HTML Preparation code:


<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/3.10.1/lodash.min.js'></script>

Script Preparation code:

function getRandomInt(max) {
  return Math.floor(Math.random() * Math.floor(max));
}

var arr = [];
for(var i = 0; i < 1000; i++){
  arr.push({value:getRandomInt(100)});
}

Tests:

_.max
_.max(arr);
Math.max
Math.max(...arr)

Historical Performance Data aggregated from 60 community runs

Desktop Results:

Chrome 52 runs

Math.max

25K/s

_.max

12K/s

Fastest: Math.max (2.0x faster)

View exact numbers

✓ Math.max: 25,334 ops/sec
• _.max: 12,469 ops/sec

Firefox 8 runs

Math.max

9K/s

_.max

4K/s

Fastest: Math.max (2.5x faster)

View exact numbers

✓ Math.max: 8,835 ops/sec
• _.max: 3,580 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
_.max
Math.max

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; rv:142.0) Gecko/20100101 Firefox/142.0

Browser/OS: Firefox 142 on Mac OS X 10.15

View result in a separate tab

Math.max

15K/s

_.max

7K/s

View exact numbers

Test name	Executions per second
✓ Math.max	14,698 Ops/sec
_.max	6,785 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark definition and test cases to explain what's being tested, the pros and cons of different approaches, and other considerations.

**Benchmark Definition JSON**

The provided JSON represents a JavaScript microbenchmarking test case. It defines two test cases: `_.max(arr)` and `Math.max(...arr)`. The test aims to compare the performance of these two functions in finding the maximum value in an array.

**Script Preparation Code**

The script preparation code generates a random array of 1000 objects with a random integer value between 0 and 100. This allows the benchmark to measure the performance of both `_.max` and `Math.max` on a large dataset.

```javascript
// Generates a random array of 1000 objects with a random integer value between 0 and 100.
function getRandomInt(max) {
  return Math.floor(Math.random() * Math.floor(max));
}

var arr = [];
for (var i = 0; i < 1000; i++) {
  arr.push({value: getRandomInt(100)});
}
```

**Html Preparation Code**

The HTML preparation code includes a reference to the Lodash library, which provides the `_` function used in the `_.max(arr)` test case.

```javascript
<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/3.10.1/lodash.min.js'></script>
```

**Individual Test Cases**

There are two individual test cases:

1. **_.max(arr)**: This test case uses the `_` function from Lodash to find the maximum value in the `arr` array.
2. **Math.max(...arr)**: This test case uses the built-in `Math.max()` function with an array spread operator (`...`) to find the maximum value in the `arr` array.

**Pros and Cons**

Here's a brief analysis of the pros and cons of each approach:

* **_.max(arr)** (Lodash):
	+ Pros:
		- Easier to write and maintain, as it's a single function.
		- Might be more readable for those familiar with Lodash.
	+ Cons:
		- Requires an external library (Lodash), which may not be included in all environments.
		- Might have performance overhead due to the external dependency.
* **Math.max(...arr)**:
	+ Pros:
		- Built-in function, so no external dependencies.
		- Often faster and more efficient, as it's a native JavaScript function.
	+ Cons:
		- More verbose and complex, with multiple functions ( `Math.max()` and the spread operator (`...`)).
		- Might require additional setup or import statements.

**Considerations**

When choosing between these two approaches, consider the following:

* Performance: If speed is critical, using the native `Math.max()` function with an array spread operator might be a better choice.
* Readability: If code readability is more important than performance, using Lodash's `_` function might be a better option.
* Maintenance: If you need to maintain or update your codebase frequently, using a single, well-maintained library like Lodash might be more convenient.

**Other Alternatives**

If you're looking for alternative approaches, consider:

* Using a different JavaScript framework or library that provides a similar `max` function (e.g., React's `maxBy`).
* Implementing your own `max` function using native JavaScript functions, such as `Math.max()` and array methods like `forEach()` and `reduce()`.
* Using a polyfill to provide the Lodash `_` function in environments where it's not included.

Keep in mind that these alternatives may have different performance characteristics or trade-offs in terms of code readability.

Lodash max vs Math.max (version: 0)

Comparing performance of: `_.max vs Math.max`

Created: 7 years ago by: Guest

Go to the latest result

_.max

Math.max

Historical Performance Data aggregated from 60 community runs

Desktop Results:

Chrome 52 runs

Firefox 8 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Lodash max vs Math.max (version: 0)

Comparing performance of: _.max vs Math.max

Created: 7 years ago by: Guest

Go to the latest result

_.max

Math.max

Historical Performance Data aggregated from 60 community runs

Desktop Results:

Chrome 52 runs

Firefox 8 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `_.max vs Math.max`