Benchmark: max-or-flat-or-apply-or-reduce

Tests:

max
const series = [ { x: 'foo', y: [ 123, 234 ] }, { x: 'bar', y: [ 234, 123, 345 ] } ]; Math.max(...series.map(({ y }) => Math.max(...y)));
flat
const series = [ { x: 'foo', y: [ 123, 234 ] }, { x: 'bar', y: [ 234, 123, 345 ] } ]; Math.max(...series.map(({ y }) => y).flat());
apply
const series = [ { x: 'foo', y: [ 123, 234 ] }, { x: 'bar', y: [ 234, 123, 345 ] } ]; Math.max.apply( null, series.map(({ y }) => Math.max.apply(null, y)) );
reduce
const series = [ { x: 'foo', y: [ 123, 234 ] }, { x: 'bar', y: [ 234, 123, 345 ] } ]; series.reduce((y1, { y }) => Math.max(y1, y.reduce((a, b) => Math.max(a, b))), 0)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
max
flat
apply
reduce

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Firefox 84 on Windows 7

View result in a separate tab

Test name	Executions per second
max	1493926.4 Ops/sec
flat	1948298.0 Ops/sec
apply	2824057.8 Ops/sec
reduce	5660622.5 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks and explore what's being tested on MeasureThat.net.

**Benchmark Definition:**

The benchmark definition is a simple JavaScript snippet that creates an array of objects with `x` and `y` properties, where `y` contains an array of numbers. The benchmark tests different ways to find the maximum value in the nested arrays.

**Options Compared:**

There are four options being compared:

1. **Math.max()**: This is a built-in JavaScript function that finds the maximum value in an array.
2. **Array.prototype.map() + Math.max()**: This approach uses `map()` to transform the inner arrays into individual numbers, and then uses `Math.max()` to find the maximum value.
3. **Array.prototype.flat() + Math.max()**: Similar to the previous option, but uses `flat()` to flatten the nested array into a single-level array before finding the maximum value.
4. **Function.prototype.apply() + Math.max()**: This approach uses `apply()` to call the `Math.max()` function on the inner arrays, bypassing the normal function invocation mechanism.

**Pros and Cons of Each Approach:**

1. **Math.max()**:
	* Pros: Fast, efficient, and widely supported.
	* Cons: May not be suitable for large datasets or complex logic.
2. **Array.prototype.map() + Math.max()**:
	* Pros: Flexible and easy to use, but can be slower than native methods due to the function invocation overhead.
	* Cons: May introduce unnecessary memory allocations or function lookups.
3. **Array.prototype.flat() + Math.max()**:
	* Pros: Similar to `map()` but with less overhead, as it uses a more efficient flattening algorithm.
	* Cons: May not be suitable for very large datasets, as it can lead to excessive memory allocation.
4. **Function.prototype.apply() + Math.max()**:
	* Pros: Can bypass the normal function invocation mechanism, potentially reducing overhead and improving performance in certain cases.
	* Cons: Less readable and less intuitive than native methods, may not be supported by all browsers or environments.

**Library Usage:**

In this benchmark, none of the options rely on external libraries. However, if we were to extend the benchmark to include more complex logic or data processing, we might need to introduce libraries like Lodash (e.g., `_.max()`), Ramda (e.g., `R.max()`), or other specialized utility libraries.

**Special JS Features/Syntax:**

The benchmark does not use any special JavaScript features or syntax that are specific to a particular browser or environment. However, it's worth noting that some of the options may have different behavior or performance characteristics in certain browsers due to differences in how they implement these methods.

**Other Alternatives:**

Some alternative approaches to finding the maximum value in an array include:

* Using `Array.prototype.reduce()` with a custom reducer function.
* Implementing a custom maximum-finding algorithm using bitwise operations or other low-level techniques.
* Using a third-party library like FastMax (a highly optimized implementation of `Math.max()` for large datasets).

These alternatives may offer better performance, readability, or maintainability in certain scenarios, but may also introduce additional complexity or dependencies.

Related benchmarks:

max-or-flat-or-apply-or-reduce (version: 0)

Comparing performance of: max vs flat vs apply vs reduce

Created: 4 years ago by: Guest

Jump to the latest result

max

flat

apply

reduce

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):