Benchmark: Max and Min values

Script Preparation code:

var data = []
   
for (var x = 1; x <= 100000; x++) {
  data.push({ x: x, y: Math.floor(Math.random() * (1000000)) })
}

Tests:

Reduce
function getMinY() { return data.reduce((min, p) => p.y < min ? p.y : min, data[0].y); } function getMaxY() { return data.reduce((max, p) => p.y > max ? p.y : max, data[0].y); } const min = getMinY(); const max = getMaxY();
For
function getMinY(){ var minY = data[0].y; var i; for (i = 1; i < data.length; i++) { if (data[i].y < minY) { minY = data[i].y; } } return minY; } function getMaxY(){ var maxY = data[0].y; var i; for (i = 1; i < data.length; i++) { if (data[i].y > maxY) { maxY = data[i].y; } } return maxY; } var min = getMinY(); var max = getMaxY();
For ternary
function getMinY(){ var minY = data[0].y; for (var i = 1; i < data.length; i++) { minY = data[i].y < minY ? data[i].y : minY; } return minY; } function getMaxY(){ var maxY = data[0].y; for (var i = 1; i < data.length; i++) { maxY = data[i].y > maxY ? data[i].y : maxY; } return maxY; } var min = getMinY(); var max = getMaxY();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Reduce
For
For ternary

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Measuring the performance of JavaScript microbenchmarks is crucial for understanding the efficiency and optimization of different programming approaches. Let's dive into the provided benchmark definition and explain what's being tested, along with the pros and cons of each approach.

**Benchmark Definition:**
The benchmark measures the performance of two methods to find the minimum and maximum values in an array:

1. `Reduce`: Using the `reduce()` method with a callback function to iterate through the array.
2. `For` and `For ternary`: Using a traditional `for` loop or a more concise version using a ternary operator.

**Script Preparation Code:**
The script generates an array of 100,000 random numbers between 0 and 1 million, which will be used as input for the benchmarking functions.

**Html Preparation Code:**
There is no HTML preparation code provided, suggesting that the benchmarking framework may not require any specific HTML setup or rendering.

**Individual Test Cases:**

### Reduce
This method uses the `reduce()` function with a callback to iterate through the array and find the minimum value. The `reduce()` function applies a binary operation (in this case, finding the smallest element) to all elements in an array, reducing it to a single output value.

Pros:

* Concise code that expresses the idea clearly.
* Efficient use of JavaScript's built-in functions.

Cons:

* May be less intuitive for developers without experience with functional programming or higher-order functions.

### For
This method uses a traditional `for` loop to iterate through the array and find the minimum and maximum values. This approach is more explicit about the iteration process.

Pros:

* More familiar to developers who are used to working with loops.
* Easier to understand for those without experience with functional programming or higher-order functions.

Cons:

* Can be less concise than using `reduce()`.
* May involve more overhead due to the loop control logic.

### For ternary
This method uses a traditional `for` loop but incorporates a ternary operator to update the minimum and maximum values. This approach is similar to the previous one but with a concise syntax.

Pros:

* Offers a balance between readability and conciseness.
* Easy to understand for developers familiar with `if` statements.

Cons:

* Less intuitive than using `reduce()` or traditional loops for those without experience with conditional statements.

**Library Usage:**
None of the provided benchmarking functions rely on external libraries. However, JavaScript's built-in functions like `Array.prototype.reduce()`, `Math.min()`, and `Math.max()` are used.

**Special JS Features/Syntax:**
The benchmark uses several standard JavaScript features:

* Arrow functions (`=>`)
* Template literals (`\r\n`)
* The spread operator (`...`)

Note that the specific syntax features mentioned (like template literals) might not be relevant to all users, as their usage can vary depending on personal coding style and familiarity with modern JavaScript.

**Other Alternatives:**
Alternative approaches for finding minimum and maximum values in an array include:

1. Using `Math.min()` and `Math.max()` functions directly on the array.
2. Implementing custom min/max functions using recursion or higher-order functions like `reduce()`.
3. Utilizing third-party libraries (like Lodash) that provide optimized implementations of these operations.

These alternatives might offer different trade-offs in terms of performance, conciseness, and readability, making them suitable for specific use cases or preferences.

Related benchmarks:

Max and Min values (version: 0)

Comparing performance of: Reduce vs For vs For ternary

Created: 8 years ago by: Guest

Jump to the latest result

Reduce

For

For ternary

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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