Benchmark: Get min value from array of objects' value 3

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)
Sort and get first element
items.sort((a, b) => a.val - b.val)[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
Sort and get first element

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 84 on Mac OS X 10.15.4

View result in a separate tab

Test name	Executions per second
Map and Math.min	3617132.5 Ops/sec
Reduce without initial value	5092262.0 Ops/sec
Reduce with initial value	3695223.5 Ops/sec
Sort and get first element	3233399.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON to understand what is being tested.

**Benchmark Definition**

The `Script Preparation Code` defines an array of objects (`items`) with a property `val`. The script preparation code is executed once, and its output is not used in any way. This suggests that the benchmark is testing the execution time of various methods on this specific input data.

**Individual Test Cases**

There are four test cases:

1. **Map and Math.min**: This test case uses the `map()` method to transform each object in the array into a single value (`item.val`) and then passes these values to the `Math.min()` function to find the minimum value.
2. **Reduce without initial value**: This test case uses the `reduce()` method with an initial value set to `items[0].val`. It iterates over each object in the array, comparing its `val` property with the accumulator (`acc`). If the current value is smaller than the accumulator, it updates the accumulator.
3. **Reduce with initial value**: This test case uses the `reduce()` method with an initial value set to `items[0].val`, just like the previous one. However, this time, no comparison is performed between the accumulator and the current value (`acc < current.val ? acc : current.val`).
4. **Sort and get first element**: This test case uses the `sort()` method to sort the array of objects in ascending order based on their `val` property. Then, it returns the `val` property of the first element after sorting.

**Libraries and Special Features**

* None are explicitly mentioned.
* No special JavaScript features or syntaxes are used in these test cases.

**Pros and Cons of Different Approaches**

1. **Map and Math.min**:
	* Pros: Simple to understand, straightforward execution.
	* Cons: May not be the most efficient approach due to the overhead of mapping each element.
2. **Reduce without initial value**:
	* Pros: Efficient for small arrays or when starting with a small initial value.
	* Cons: Can lead to stack overflow errors if the array is too large and the recursion depth exceeds the maximum allowed.
3. **Reduce with initial value**:
	* Pros: Similar efficiency benefits as above, but avoids potential stack overflow issues due to the explicit initial value.
	* Cons: Requires careful consideration of the initial value choice, which may not always be optimal.
4. **Sort and get first element**:
	* Pros: Simple to understand, but can lead to slower execution times compared to other approaches due to the sorting step.

**Other Alternatives**

Some possible alternatives could include:

1. Using `Array.prototype.every()` instead of `Math.min()`: This would check if all elements in the array satisfy a certain condition (in this case, being greater than or equal to the initial value).
2. Employing a custom sorting function that only compares values without modifying them.
3. Utilizing other libraries like Lodash's `minBy()` or `sortBy()` functions.

Keep in mind that these alternatives may introduce additional complexity and potentially alter the benchmark's results.

Related benchmarks:

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

Comparing performance of: Map and Math.min vs Reduce without initial value vs Reduce with initial value vs Sort and get first element

Created: 4 years ago by: Guest

Jump to the latest result

Map and Math.min

Reduce without initial value

Reduce with initial value

Sort and get first element

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):