Benchmark: Min/max for array

Script Preparation code:

var data = [ ...Array(100).keys() ].map(() => {
  let value = Math.floor(Math.random() * 10000);
  if(value > 9000) return {value: null};
  return {value};
});

Tests:

Math.min/max with spread
let testData = data.map(d => d['value']).filter(d => d != null); let hasValidValues = testData.length > 0; var min = Math.min(...testData); var max = Math.max(...testData);
forEach
let min = Number.MAX_VALUE; let max = Number.MIN_VALUE; let hasValidValues = data.some(d => d['value']); data.forEach(obj => { const value = obj['value']; if (value == null) return; if (value < min) min = value; if (value > max) max = value; });
Reducer
let hasValidValues = data.some(d => d['value'] != null); const res = data.reduce((acc, d) => { const value = d['value']; if(value != null){ if (value < acc.mmin) acc.min = value; if (value > acc.max) acc.max = value; } return acc; }, {min: Number.MAX_VALUE, max: Number.MIN_VALUE});
forEach with hasValidValues in loop
let min = Number.MAX_VALUE; let max = Number.MIN_VALUE; let hasValidValues = false; data.forEach(obj => { if ('value' in obj) { const value = obj['value']; if (value === null) return; hasValidValues = true; if (value < min) min = value; if (value > max) max = value; } });
apply
let testData = data.map(d => d['value']).filter(d => d != null); let hasValidValues = testData.length > 0; var min = Math.min.apply(null, testData); var max = Math.max.apply(null, testData);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Math.min/max with spread
forEach
Reducer
forEach with hasValidValues in loop
apply

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark definition and test cases.

**Benchmark Definition:**

The benchmark measures the performance of finding the minimum and maximum values in an array with some null values. The data is generated using JavaScript, and the array contains 100 elements with random values between 0 and 10,000. Some elements are set to null.

**Test Cases:**

There are four test cases that measure different approaches for finding the minimum and maximum values:

1. **"Math.min/max with spread"**: Uses the `map()` method followed by `filter()` to extract non-null values from the array. Then, it uses `Math.min()` and `Math.max()` to find the smallest and largest values in the filtered array.
2. **"forEach"**: Iterates over the array using a `for...of` loop and checks each element for nullness. If an element is not null, it updates the minimum and maximum values accordingly.
3. **"Reducer"**: Uses the `reduce()` method to iterate over the array and find the minimum and maximum values. It keeps track of the current minimum and maximum values in a accumulator object.
4. **"apply"**: Similar to "forEach", but uses the `Math.min.apply(null)` and `Math.max.apply(null)` methods to call the min and max functions.

**Library Usage:**

None, as this benchmark does not use any external libraries or frameworks.

**Special JS Features/Syntax:**

* None mentioned in the benchmark definition. However, note that some test cases use ES6+ syntax, such as `for...of` loops and arrow functions (`=>`). These are supported by most modern JavaScript engines, including Chrome 98.
* The `reduce()` method is used in two test cases, which may not be familiar to developers without experience with this function.

**Pros and Cons:**

1. **"Math.min/max with spread"**: Pros:
	* Simple and concise code
	* Fast, as it only iterates over the filtered array
Cons:
	* May create temporary arrays, which can lead to memory allocation overhead
2. **"forEach"**: Pros:
	* Easy to understand and implement
	* Allows for direct access to array elements
Cons:
	* Can be slower due to the explicit loop and checks for nullness
3. **"Reducer"**: Pros:
	* Efficient, as it only iterates over the array once
	* Can be more readable than a simple loop
Cons:
	* May require more mental effort to understand the accumulator logic
4. **"apply"**: Similar pros and cons as "forEach", but with the added overhead of function calls.

**Other Alternatives:**

1. **`Array.prototype.reduce()` without an initial value**: This can be used instead of `reduce()` if you want to start from a specific initial minimum or maximum value.
2. **`Array.prototype.every()` and `Array.prototype.some()`**: These methods can be used to check for nullness in the array elements, but may not provide the same flexibility as the `forEach` approach.

In summary, each test case has its strengths and weaknesses. The choice of implementation depends on the specific requirements and trade-offs you're willing to make.

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/98.0.4758.102 Safari/537.36

Browser/OS: Chrome 98 on Windows

View result in a separate tab

Test name	Executions per second
Math.min/max with spread	344318.5 Ops/sec
forEach	752359.4 Ops/sec
Reducer	251110.0 Ops/sec
forEach with hasValidValues in loop	860522.8 Ops/sec
apply	363407.1 Ops/sec

Related benchmarks:

Min/max for array (version: 0)

Comparing performance of: Math.min/max with spread vs forEach vs Reducer vs forEach with hasValidValues in loop vs apply

Created: 2 years ago by: Guest

Jump to the latest result

Math.min/max with spread

forEach

Reducer

forEach with hasValidValues in loop

apply

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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