Benchmark: Hello_12312313 - MeasureThat.net

Script Preparation code:

var data = new Map(Object.entries(Array.from(Array(100000).keys()).reduce((k,v)=>{ if (k !== undefined && typeof v !== undefined) { k[v] = v; return k } },{})))

Tests:

Object.fromEntries
Object.fromEntries(Object.entries(data).map((key, value) => [key, value]));
Reduce (reuse object)
Object.entries(data).reduce((acc, [k, v]) => { acc[k] = v.toString(); return acc; }, {});
Reduce (creating temporary objects)
Object.entries(data).reduce((acc, [k, v]) => ({ ...acc, [k]: v.toString() }), {});

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.fromEntries
Reduce (reuse object)
Reduce (creating temporary objects)

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 108 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Object.fromEntries	4637250.0 Ops/sec
Reduce (reuse object)	7166457.0 Ops/sec
Reduce (creating temporary objects)	7159824.5 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):

LLMs can make mistakes. Check important info.

Let's break down the provided JSON data and explain what is being tested in this JavaScript microbenchmark.

**Overview**

The benchmark measures the performance of three different approaches for converting a Map object to an Object:

1. `Object.fromEntries`
2. `Object.entries.reduce` with two variations:
	* Reusing the accumulator object (`Reduce (reuse object)`)
	* Creating temporary objects during reduction (`Reduce (creating temporary objects)`)

**Options being compared**

The benchmark compares the performance of these three approaches on a specific input:

* The input is a large Map object created using `Array.from(Array(100000).keys()).reduce((k,v)=>{ if (k !== undefined && typeof v !== undefined) { k[v] = v; return k } },{})`.
* This map contains 100,000 key-value pairs where each value is also an array of 100,000 elements.

**Pros and Cons**

Here's a brief analysis of the pros and cons of each approach:

1. **`Object.fromEntries`**: This method is part of the ECMAScript 2015 (ES6) standard and provides a concise way to convert a Map object to an Object.
	* Pros: Fast, modern, and widely supported.
	* Cons: May not be available in older browsers or environments.
2. **`Object.entries.reduce(reuse object)`**: This method reuses the accumulator object to store the key-value pairs.
	* Pros: Can be faster than creating temporary objects during reduction.
	* Cons: May lead to performance issues if the accumulator object grows too large, as it can cause garbage collection overhead.
3. **`Object.entries.reduce(creating temporary objects)`**: This method creates a new Object instance during reduction, which can lead to slower performance due to object creation overhead.
	* Pros: None apparent that outweighs the potential benefits of avoiding object reuse.
	* Cons: Potentially slower than `reuse object` approach.

**Library**

There is no explicit library used in this benchmark. However, it relies on built-in JavaScript features and objects (e.g., Map, Object).

**Special JS feature or syntax**

The benchmark uses ECMAScript 2015 (ES6) syntax, specifically the `let const` block syntax (`if (k !== undefined && typeof v !== undefined)`) for creating a conditional expression.

**Alternatives**

If you want to run this benchmark on a different platform or use a different approach, you can consider:

* Using a different input data structure, such as an array of objects or a custom implementation.
* Implementing your own `Object.fromEntries` or `reduce` implementations for better control over the conversion process.
* Using a browser or environment that supports older JavaScript features or has limitations on performance.

Keep in mind that the benchmark's results may vary depending on the specific platform, hardware, and JavaScript engine used.

Related benchmarks:

Hello_12312313 (version: 0)

123123

Comparing performance of: Object.fromEntries vs Reduce (reuse object) vs Reduce (creating temporary objects)

Created: 2 years ago by: Guest

Jump to the latest result

Object.fromEntries

Reduce (reuse object)

Reduce (creating temporary objects)

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):