Benchmark: Math.min and Math.max vs reduce vs for for 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, data[0]);
Reduce for max
data.reduce((max, cur) => max < cur ? cur : max, data[0]);
For for min
var min = data[0]; for (var i = 1; i < data.length; ++i) { var c = i; if (min > c) min = c; }
For for max
var max = data[0]; for (var i = 1; i < data.length; ++i) { var c = i; if (max < c) max = c; }
For of for min
var min = data[0]; for (var c in data) { if (min > c) min = c; }
For of for max
var max = data[0]; for (var c in 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

Latest run results:

Run details: (Test run date: 7 days ago)

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

Browser/OS: Chrome 135 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Math.Min	4635.8 Ops/sec
Math.Max	4714.2 Ops/sec
Reduce for min	1469.2 Ops/sec
Reduce for max	1595.3 Ops/sec
For for min	10807.8 Ops/sec
For for max	9918.0 Ops/sec
For of for min	613.5 Ops/sec
For of for max	593.6 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Overview**

The benchmark compares four different approaches to find the minimum or maximum value in an array of 100,000 random numbers:

1. `Math.min()` and `Math.max()`
2. Reduction with a callback function (`data.reduce()`)
3. Two types of for loops (`for` and `for...in`)
4. Two variants of `for...in` loop with different indexing (`for in` with array indexing)

**Options Compared**

The benchmark tests the following options:

1. **Math.min()** and **Math.max()**: These are built-in functions that find the minimum or maximum value in an array, respectively.
2. **Reduction with a callback function (`data.reduce()`)**: This approach uses the `reduce()` method to iterate over the array and find the minimum or maximum value.
3. **Two types of for loops**:
	* **Classic for loop**: This is a simple for loop that iterates over the array using an index variable.
	* **For loop with array indexing (`for (var i = 0; i < data.length; ++i)`)**: This approach uses an index variable to iterate over the array, similar to the classic for loop.
4. **Two variants of `for...in` loop**:
	* **Classic for...in loop**: This is a for loop that iterates over the array using the `for...in` syntax, which enumerates properties of the object (in this case, the array).
	* **For...in with array indexing (`for (var c in data)`)**: This approach uses the `for...in` syntax to iterate over the array and access its elements.

**Pros and Cons**

Here are some pros and cons for each option:

1. **Math.min()** and **Math.max()**:
	* Pros: Simple, fast, and efficient.
	* Cons: Limited control over the iteration process.
2. **Reduction with a callback function (`data.reduce()`)**:
	* Pros: Flexible, concise, and can be used for more complex operations.
	* Cons: May have performance overhead due to the callback function evaluation.
3. **Classic for loop**:
	* Pros: Simple, efficient, and well understood.
	* Cons: Requires manual indexing and control over the iteration process.
4. **For loop with array indexing (`for (var i = 0; i < data.length; ++i)`)**:
	* Pros: Similar to a classic for loop but with array indexing.
	* Cons: Still requires manual indexing and control over the iteration process.
5. **Classic for...in loop**:
	* Pros: Simple, efficient, and well understood.
	* Cons: Iterates over properties of the object (array), not indices.
6. **For...in with array indexing (`for (var c in data)`)**:
	* Pros: Similar to a classic for loop but uses `for...in` syntax.
	* Cons: Iterates over properties of the object (array), not indices.

**Performance**

The performance results show that `Math.min()` and `Math.max()` are generally the fastest approaches, followed by the reduction with a callback function. The for loops and for-in variants have varying performance depending on the indexing approach used.

In summary, the benchmark highlights the importance of choosing the right algorithmic approach based on the specific requirements of your use case. While `Math.min()` and `Math.max()` are simple and efficient, the reduction with a callback function offers more flexibility and can be useful for more complex operations. The for loops and for-in variants require manual indexing and control over the iteration process but offer simplicity and efficiency in their own right.

Related benchmarks:

Math.min and Math.max vs reduce vs for for 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: 5 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 6 months ago):