Benchmark: Array to object - MeasureThat.net

Script Preparation code:

// Creates an array like [[ '0': 0 ], [ '1': 1 ], ... ]
var data = Object.entries({...Array.from(new Array(100000).keys())});

Tests:

Reduce w/ temp objects
data.reduce((acc, [k, v]) => ({ ...acc, [k]: v }), {})
for
var obj = {}; for (var i = 0; i < data.length; i++) { var [k, v] = data[i]; obj[k] = v; }
Object.fromEntries
Object.fromEntries(data)
Reduce
data.reduce((acc, [k, v]) => { acc[k] = v; return acc; }, {})
For..of
var obj = {}; for (var [k, v] of data) { obj[k] = v; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Reduce w/ temp objects
for
Object.fromEntries
Reduce
For..of

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_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.125 Safari/537.36

Browser/OS: Chrome 84 on Mac OS X 10.15.6

View result in a separate tab

Test name	Executions per second
Reduce w/ temp objects	0.1 Ops/sec
for	60.5 Ops/sec
Object.fromEntries	116.0 Ops/sec
Reduce	268.9 Ops/sec
For..of	371.5 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 definition and test cases, explaining what's being tested and discussing the pros and cons of different approaches.

**Benchmark Definition**

The benchmark measures the performance of various JavaScript methods for converting an array-like object to a plain object.

**Options Compared**

Four options are compared:

1. **Reduce**: A method that iterates over the array-like object and accumulates the values into a new object.
2. **For loop**: A traditional loop construct that iterates over the array-like object and adds each value to a new object.
3. **Object.fromEntries**: A method that creates an object from an iterable array of key-value pairs.
4. **For...of loop**: A newer loop construct (introduced in ECMAScript 2017) that allows iterating over arrays without using the traditional `for` loop.

**Pros and Cons**

Here's a brief overview of each option:

1. **Reduce**:
	* Pros: Efficient use of memory, can be implemented with just a single pass through the array.
	* Cons: Can be slower due to the overhead of function calls, and may not perform as well for large arrays.
2. **For loop**:
	* Pros: Easy to understand and implement, can be optimized for performance by using caching or other techniques.
	* Cons: Uses more memory than `Reduce`, and may require multiple passes through the array.
3. **Object.fromEntries**:
	* Pros: Fast and efficient, uses modern JavaScript syntax that's easy to read and write.
	* Cons: May not be supported in older browsers or environments, requires a modern JavaScript engine.
4. **For...of loop**:
	* Pros: Modern and expressive syntax, can be optimized for performance using caching or other techniques.
	* Cons: May require a recent JavaScript engine to support, and may have slower performance compared to `Reduce`.

**Library/ Framework**

None of the options listed use a library or framework. However, the benchmark uses modern JavaScript features like `Object.fromEntries`, which is supported in most modern browsers.

**Special JS Feature/Syntax**

The test cases use the newer **For...of loop** syntax (introduced in ECMAScript 2017), which allows iterating over arrays without using a traditional `for` loop. This feature is not widely supported in older browsers or environments, and may require a recent JavaScript engine to support.

**Other Alternatives**

If none of these options are suitable for your use case, you might consider:

1. Using a library like **Lodash**, which provides optimized implementations of various array methods.
2. Implementing a custom loop construct using `for` loops or other techniques.
3. Using a different data structure, such as an object with a single key-value pair per element, to avoid the need for iteration.

Keep in mind that each option has its trade-offs and may be better suited for specific use cases or performance profiles.

Related benchmarks:

Array to object (version: 1)

Comparing performance of: Reduce w/ temp objects vs for vs Object.fromEntries vs Reduce vs For..of

Created: 4 years ago by: Registered User

Jump to the latest result

Reduce w/ temp objects

for

Object.fromEntries

Reduce

For..of

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