Benchmark: Object.fromEntries vs reduce for filtering keys

Script Preparation code:

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

Tests:

Object.fromEntries
Object.fromEntries(Object.entries(data).filter((key, value) => value % 2 === 0));
Reduce (reuse object)
Object.entries(data).reduce((acc, [key, value]) => { if (value % 2 === 0) { acc[key] = value; } return acc; }, {});
Reduce (creating temporary objects)
Object.entries(data).reduce((acc, [k, v]) => ({ ...acc, ...(v % 2 === 0 && {[k]: v}) }), {});

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: one year ago)

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

Browser/OS: Firefox 113 on Ubuntu

View result in a separate tab

Test name	Executions per second
Object.fromEntries	735.2 Ops/sec
Reduce (reuse object)	979.6 Ops/sec
Reduce (creating temporary objects)	0.2 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and its various components.

**Benchmark Overview**

The benchmark compares three approaches to filter keys in an object:

1. Using `Object.fromEntries` with a filtered array of key-value pairs.
2. Using the `reduce()` method on the `Object.entries()` iterator, reusing an accumulator object for each iteration.
3. Using the `reduce()` method on the `Object.entries()` iterator, creating temporary objects for each iteration.

**Options Compared**

The benchmark compares the performance of these three approaches:

* **Approach 1: Object.fromEntries**: This approach uses the `Object.fromEntries()` method to create an object from an array of key-value pairs. The filtered array is created using the `filter()` method.
* **Approach 2: Reduce (reuse object)**: This approach uses the `reduce()` method on the `Object.entries()` iterator, reusing an accumulator object for each iteration. The accumulator is initialized as an empty object `{}` and updated with the filtered key-value pairs.
* **Approach 3: Reduce (creating temporary objects)**: This approach also uses the `reduce()` method on the `Object.entries()` iterator, but creates a new temporary object for each iteration instead of reusing an existing one.

**Pros and Cons**

Here are some pros and cons of each approach:

* **Approach 1: Object.fromEntries**: Pros:
	+ Shorter code and easier to read.
	+ Less memory allocation and garbage collection overhead.
*   Cons:
	+ May have slower performance due to the creation of a new object.
*   Approach 2: Reduce (reuse object):
	+ Reuses existing accumulator objects, reducing memory allocation and garbage collection overhead.
	+ Can be faster than Approach 1 due to reduced object creation.
*   Pros:
	+ Reduces memory allocation and garbage collection overhead.
	+ Can be faster than Approach 1 due to reduced object creation.
*   Cons:
	+ More complex code due to the need to manage an accumulator object.
*   Approach 3: Reduce (creating temporary objects):
	+ Creates a new temporary object for each iteration, which can lead to increased memory allocation and garbage collection overhead.
	+ Typically slower than Approach 2.

**Library Used**

None of the benchmark options explicitly use any external libraries. However, `Object.entries()` is a built-in JavaScript method that returns an array-like iterator over the key-value pairs of an object.

**Special JS Features or Syntax**

The benchmark uses several advanced JavaScript features:

*   The `reduce()` method, which is a part of the Array prototype.
*   Template literals (`...`), used to create new objects in Approach 3.
*   Arrow functions (`=>`), used in the callback function of the `reduce()` method.

These features are not specific to JavaScript and can be found in many other programming languages.

**Alternatives**

Other alternatives for filtering keys in an object include:

* Using a loop with indexing (e.g., `data[key] === value % 2 ? data[key] : undefined`).
* Using the `filter()` method on an array of key-value pairs, followed by creating an object from the filtered array using the `Object.fromEntries()` method.
* Using a library like Lodash, which provides a `pickBy()` function for filtering keys in objects.

These alternatives may have different performance characteristics and code readability compared to the benchmark options.

Related benchmarks:

Object.fromEntries vs reduce for filtering keys (version: 0)

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

Created: one year 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 2 months ago):