Benchmark: Math.min and Math.max vs reduce vs for for range 100000 items.

Script Preparation code:

var data = [];
for (var i = 0; i < 100000; ++i) data.push(Math.random());

Tests:

Math.Min
Math.min(...data);
Math.Max
Math.max(...data);
Reduce for min
data.reduce((min, cur) => min > cur ? cur : min);
Reduce for max
data.reduce((max, cur) => max < cur ? cur : max);
For for min
var min = data[0]; for (var i = 1; i < data.length; ++i) { const c = data[i]; if (min > c) min = c; }
For for max
var max = data[0]; for (var i = 1; i < data.length; ++i) { const c = data[i]; if (max < c) max = c; }
For of for min
var min = data[0]; for (const c of data) { if (min > c) min = c; }
For of for max
var max = data[0]; for (const c of data) { if (max < c) max = c; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Math.Min
Math.Max
Reduce for min
Reduce for max
For for min
For for max
For of for min
For of for max

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Measuring performance is essential to understand the efficiency and speed of different algorithms in JavaScript.

The provided benchmark, `Math.min and Math.max vs reduce vs for range 100000 items`, compares the execution times of three approaches: using built-in functions (`Math.min` and `Math.max`) versus two methods with loops (`reduce` and `for`). We'll break down each approach:

**Built-in Functions (Math.min and Math.max)**

These functions are optimized by JavaScript engines for performance. They work directly on the primitive values of the input array, making them potentially faster.

Pros:

* Built-in functions are typically well-optimized.
* Easy to use and understand.

Cons:

* May not be as flexible or customizable as other approaches.
* Can be slower if the input array is large, since they need to iterate over all elements to find the minimum/maximum value.

**Reduce Method**

The `reduce` method applies a binary function (in this case, comparing two values) to each element in an array, accumulating a result. This approach can be more efficient than loops for some use cases.

Pros:

* Can be faster for large arrays, as it avoids explicit loop iterations.
* Allows for more flexibility in customization and handling edge cases.

Cons:

* Requires knowledge of the accumulator variable and how to handle it correctly.
* May have performance overhead due to the creation of an intermediate result object.

**For Loop**

A simple `for` loop iterates over each element in the array, comparing it with the current minimum/maximum value. This approach is straightforward but can be slower than optimized built-in functions or more efficient reduce methods.

Pros:

* Easy to understand and implement.
* No additional library dependencies required.

Cons:

* Can be slower due to explicit loop iterations.
* Requires more manual handling of edge cases (e.g., initializing the minimum/maximum value).

**For...Of Loop**

The `for...of` loop is a more modern iteration method that allows iterating over arrays without the need for an index variable. This approach can be faster and more efficient than traditional `for` loops.

Pros:

* Allows for more concise code.
* Can be faster due to reduced overhead compared to traditional `for` loops.

Cons:

* Requires knowledge of the new iteration syntax.
* May not be supported in older browsers or environments.

**Other Considerations**

Keep in mind that these comparisons assume a simple array of random values. The performance differences may vary depending on the specific use case, input data distribution, and other factors.

When working with large datasets or complex algorithms, consider using optimized libraries like Lodash or UglifyJS to further improve performance.

Now, you might wonder why `For of` loops are faster than traditional `for` loops. This is because modern JavaScript engines (e.g., V8 in Chrome) have optimized the `for...of` loop to avoid unnecessary overheads associated with indexing and array lookups.

Ultimately, choose the approach that best suits your specific requirements and performance constraints.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36

Browser/OS: Chrome 103 on Windows

View result in a separate tab

Test name	Executions per second
Math.Min	664.6 Ops/sec
Math.Max	725.1 Ops/sec
Reduce for min	1076.4 Ops/sec
Reduce for max	944.9 Ops/sec
For for min	51.2 Ops/sec
For for max	56.9 Ops/sec
For of for min	2822.6 Ops/sec
For of for max	2310.3 Ops/sec

Related benchmarks:

Math.min and Math.max vs reduce vs for for range 100000 items. (version: 0)

Comparing performance of: Math.Min vs Math.Max vs Reduce for min vs Reduce for max vs For for min vs For for max vs For of for min vs For of for max

Created: 2 years ago by: Guest

Jump to the latest result

Math.Min

Math.Max

Reduce for min

Reduce for max

For for min

For for max

For of for min

For of for max

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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