Benchmark: Object.fromEntries vs reduce 341235

Script Preparation code:

var data = { ...Array.from(Array(10000).keys()) };

Tests:

Object.fromEntries
Object.fromEntries(Object.entries(data).map((key, value) => [key, null]));
Reduce (reuse object)
Object.entries(data).reduce((acc, [k, v]) => { acc[k] = null; return acc; }, {});
Object.fromEntries with reduce
Object.fromEntries(Object.entries(data).reduce((acc, [k, v], i) => { acc.push([k, null]); return acc; }, []));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.fromEntries
Reduce (reuse object)
Object.fromEntries with reduce

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:91.0) Gecko/20100101 Firefox/91.0

Browser/OS: Firefox 91 on Ubuntu

View result in a separate tab

Test name	Executions per second
Object.fromEntries	122.3 Ops/sec
Reduce (reuse object)	722.7 Ops/sec
Object.fromEntries with reduce	361.3 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**What is tested:**
The provided JSON represents a benchmark test case that compares three approaches for creating an object from an array of key-value pairs:

1. Using `Object.fromEntries()`
2. Using the `reduce()` method
3. Using `Object.fromEntries()` with the `reduce()` method

These approaches are compared to measure their performance and efficiency.

**Options comparison:**

*   **`Object.fromEntries()`**: This is a modern JavaScript method introduced in ECMAScript 2019, which creates an object from an array of key-value pairs. It's designed to be efficient and concise.
*   **Reduce() method**: The `reduce()` method is a built-in JavaScript function that applies a user-supplied function to each element of an array (in this case, the key-value pairs) and reduces it to a single output value. In this benchmark, it's used to create an object by pushing key-value pairs into an accumulator object.
*   **`Object.fromEntries()` with reduce()**: This approach is similar to the previous one but uses `reduce()` to transform the array of key-value pairs into an object before passing it to `Object.fromEntries()`.

**Pros and Cons:**

*   **`Object.fromEntries()`**:
    *   Pros:
        *   Efficient and concise
        *   Modern JavaScript standard
    *   Cons:
        *   Requires modern browsers or JavaScript engines that support ECMAScript 2019
*   **Reduce() method**:
    *   Pros:
        *   Widely supported in older browsers and JavaScript engines
        *   Can be useful for other array processing tasks beyond object creation
    *   Cons:
        *   Less efficient than `Object.fromEntries()` for object creation
        *   Requires more code and manual memory management (using an accumulator object)
*   **`Object.fromEntries()` with reduce()**:
    *   Pros:
        *   Combines the benefits of both approaches: modern syntax and efficiency
    *   Cons:
        *   Still requires modern browsers or JavaScript engines

**Library usage:**
None of the provided benchmark test cases use external libraries.

**Special JS features/syntax:**
The `Object.fromEntries()` method uses a new, modern JavaScript feature introduced in ECMAScript 2019. This syntax allows creating an object from an array of key-value pairs in a concise and efficient way.

**Other alternatives:**

*   Other ways to create objects from arrays include using `Array.prototype.reduce()` or loops with manual memory management.
*   Alternatively, you could use libraries like Lodash or Ramda for functional programming tasks, but this is not the case here as no external library is used.

These alternatives would likely have different performance characteristics and code complexity compared to the benchmarked approaches.

Related benchmarks:

Object.fromEntries vs reduce 341235 (version: 0)

Comparing performance of: Object.fromEntries vs Reduce (reuse object) vs Object.fromEntries with reduce

Created: 2 years ago by: Guest

Jump to the latest result

Object.fromEntries

Reduce (reuse object)

Object.fromEntries with reduce

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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