Benchmark: Get min value from array of objects' value

Script Preparation code:

var items = [{
        val: 7
    },
    {
        val: 9
    },
    {
        val: 8
    },
    {
        val: 3
    },
    {
        val: 12
    },
    {
        val: 34
    },
    {
        val: 7
    },
    {
        val: 512
    }
]

Tests:

Map and Math.min
Math.min(...items.map(item => item.val))
Reduce without initial value
items.reduce((acc, current) => acc < current.val ? acc : current.val)
Reduce with initial value
items.reduce((acc, current) => acc < current.val ? acc : current.val, items[0].val)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Map and Math.min
Reduce without initial value
Reduce with initial value

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.105 Safari/537.36

Browser/OS: Chrome 84 on Linux

View result in a separate tab

Test name	Executions per second
Map and Math.min	910430.1 Ops/sec
Reduce without initial value	2347956.2 Ops/sec
Reduce with initial value	1831322.9 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark test cases, explain what's being tested, compare different approaches, and highlight pros and cons of each method.

**Benchmark Definition**
The benchmark defines a JavaScript function that takes an array of objects with a `val` property as input. The goal is to find the minimum value in this array.

**Script Preparation Code**
The script preparation code creates a sample array of 8 objects with varying `val` values:
```javascript
var items = [{ val: 7 }, { val: 9 }, { val: 8 }, { val: 3 }, { val: 12 }, { val: 34 }, { val: 7 }, { val: 512 }];
```
**Html Preparation Code**
There is no HTML preparation code provided.

**Individual Test Cases**
The benchmark consists of three test cases, each with a different approach to find the minimum value in the array:

1. **Map and Math.min**
```javascript
Math.min(...items.map(item => item.val));
```
This test case uses the `map` method to create an array of values from the original array, and then passes this new array to `Math.min()`.

2. **Reduce without initial value**
```javascript
items.reduce((acc, current) => acc < current.val ? acc : current.val);
```
This test case uses the `reduce` method with no initial value to iterate through the array and find the minimum value.

3. **Reduce with initial value**
```javascript
items.reduce((acc, current) => acc < current.val ? acc : current.val, items[0].val);
```
This test case uses the `reduce` method with an initial value of the first element in the array to iterate through the array and find the minimum value.

**Options Comparison**

* **Map and Math.min**: This approach is concise but may incur additional overhead due to function calls and intermediate arrays.
	+ Pros: Easy to read and maintain, no explicit loops required.
	+ Cons: May be slower than other approaches due to unnecessary function calls.
* **Reduce without initial value**: This approach uses the `reduce` method with a callback function to iterate through the array.
	+ Pros: Can be faster than Map and Math.min due to reduced overhead, allows for more control over the iteration process.
	+ Cons: Requires understanding of the `reduce` method and its behavior.
* **Reduce with initial value**: This approach uses the `reduce` method with an initial value to initialize the accumulator variable.
	+ Pros: Can be faster than Reduce without initial value due to reduced overhead, allows for more control over the iteration process.
	+ Cons: Requires understanding of the `reduce` method and its behavior.

**Libraries Used**

None explicitly mentioned in the benchmark definition. However, it is likely that libraries like Lodash or Ramda might be used if not for the `map` and `reduce` functions, which are built-in JavaScript methods.

**Special JS Features/Syntax**

No special JavaScript features or syntax are mentioned in the benchmark definition. The tests only use standard JavaScript syntax and built-in methods.

**Other Alternatives**

For finding the minimum value in an array, other approaches might include:

* Using a loop with indexing to iterate through the array
* Utilizing a sorting algorithm like QuickSort or Merge Sort
* Using a library like Lodash's `min` function

Keep in mind that each approach has its own trade-offs and may be more suitable for specific use cases.

Related benchmarks:

Get min value from array of objects' value (version: 0)

Comparing performance of: Map and Math.min vs Reduce without initial value vs Reduce with initial value

Created: 4 years ago by: Guest

Jump to the latest result

Map and Math.min

Reduce without initial value

Reduce with initial value

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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