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

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)
Reduce without initial value 2
items.reduce((acc, current) => acc > current.val ? current.val : acc)

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
Reduce without initial value 2

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	3553170.2 Ops/sec
Reduce without initial value	5112774.0 Ops/sec
Reduce with initial value	3686865.5 Ops/sec
Reduce without initial value 2	1440307.1 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 JSON and explain what's being tested, compared, and considered.

**Benchmark Definition**

The benchmark is defined by two scripts: one for preparing data (`Script Preparation Code`) and none for HTML preparation. The prepared data consists of an array of objects with a single property `val`. The purpose of this benchmark is to measure the performance of different approaches to find the minimum value in an array of objects.

**Individual Test Cases**

There are four test cases, each defining a different approach:

1. **Map and Math.min**: Maps the `items` array to extract the `val` property from each object using `item => item.val`, and then uses `Math.min()` to find the minimum value.
2. **Reduce without initial value**: Uses the `reduce()` method with an initial value of `undefined` (which will be considered as `-Infinity`) to iterate through the array and update the accumulator (`acc`) if a smaller value is found.
3. **Reduce with initial value**: Similar to the previous test case, but uses the first element of the array (`items[0].val`) as the initial value.
4. **Reduce without initial value 2**: The same approach as the second test case, but starts with an initial value of `2` instead of `-Infinity`.

**Comparison**

The comparison being made is between these four approaches to find the minimum value in the array:

* Map and Math.min vs Reduce without initial value
* Map and Math.min vs Reduce with initial value
* Reduce without initial value vs Reduce with initial value

**Pros and Cons:**

1. **Map and Math.min**:
	* Pros: Simple, concise, and easy to read.
	* Cons: May incur overhead from function calls (`map()` and `Math.min()`).
2. **Reduce without initial value**:
	* Pros: Efficient use of accumulator update.
	* Cons: Requires careful handling of edge cases (e.g., empty array, negative numbers).
3. **Reduce with initial value**:
	* Pros: Convenient for cases where the first element is a good starting point.
	* Cons: May not be as efficient as `reduce()` without an initial value.

**Other Considerations**

* In terms of performance, using `map()` followed by `Math.min()` may incur additional overhead compared to other approaches.
* Using `reduce()` with an initial value can lead to better cache locality and reduced overhead compared to other approaches.

**Browser-Specific Notes**

The benchmark results indicate that Chrome 84 on a Mac OS X 10.15.4 desktop is the fastest browser, followed closely by another instance of the same browser. The performance difference between reduce without initial value and reduce with initial value suggests that starting with a known good value can be beneficial.

**Library Usage**

There are no specific libraries used in this benchmark, only built-in JavaScript functions (`map()`, `Math.min()`, `reduce()`).

No special JavaScript features or syntax are being tested in this benchmark.

Related benchmarks:

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

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

Created: 4 years ago by: Guest

Jump to the latest result

Map and Math.min

Reduce without initial value

Reduce with initial value

Reduce without initial value 2

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