Benchmark: Object filter: fromEntries vs reduce (with keys & entries)

Script Preparation code:

var items = { ...Array.from(Array(10000).keys()) };
var itemsToFilter = Array.from(Array(10000).keys()).filter(v => v % 2 === 0);

Tests:

Object.fromEntries
var filteredObject = Object.entries(items).filter(([key]) => itemsToFilter.includes(key)); Object.fromEntries(filteredObject);
Object.keys + reduce
Object.keys(items).reduce((acc, key) => { if (itemsToFilter.includes(key)) { acc[key] = items[key]; } return acc; }, {});
Object.entries + reduce
Object.entries(items).reduce((acc, [key, entry]) => { if (itemsToFilter.includes(key)) { acc[key] = entry; } return acc; }, {});

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.fromEntries
Object.keys + reduce
Object.entries + reduce

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 110 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Object.fromEntries	15.7 Ops/sec
Object.keys + reduce	15.8 Ops/sec
Object.entries + reduce	15.7 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 components.

**Benchmark Definition**

The provided JSON represents a JavaScript microbenchmark that compares three approaches to filter an object using two popular methods: `Object.keys()`, `reduce()`, and `Object.fromEntries()` with or without the `entries` property. The goal is to determine which approach is faster for this specific use case.

**Options Compared**

Three options are being compared:

1. **Object.keys() + reduce()**: This option uses the `keys()` method to get an array of keys from the object, and then applies the `reduce()` method to filter and transform the data.
2. **Object.entries() + reduce()**: Similar to the previous option, but this time it uses the `entries()` method to get an array of key-value pairs from the object.
3. **Object.fromEntries()**: This option uses the `fromEntries()` method to create a new object from an iterable (in this case, the filtered key-value pairs).

**Pros and Cons of Each Approach**

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

1. **Object.keys() + reduce()**:
	* Pros: Can be more efficient for large datasets since it only iterates over the keys.
	* Cons: May have performance issues when dealing with sparse objects or objects with many duplicate keys.
2. **Object.entries() + reduce()**:
	* Pros: Allows for more flexible filtering and transformation, as it directly works with key-value pairs.
	* Cons: May be slower than `keys()` due to the extra iteration over the key-value pairs.
3. **Object.fromEntries()**:
	* Pros: Provides a concise and readable way to create an object from an iterable.
	* Cons: May have performance issues when dealing with large datasets or objects, as it creates a new object copy.

**Library**

None of these approaches rely on specific libraries beyond the standard JavaScript built-in methods. However, `Object.fromEntries()` is a relatively recent addition to the ECMAScript standard (ES2022), so some older browsers might not support it.

**Special JS Feature/Syntax**

The benchmark does use some special JavaScript features:

* **Spread operator (`...`)**: Used in the `itemsToFilter` variable initialization.
* **Template literals (`\r\n`)**: Used for code formatting and readability.
* **Arrow functions (`=>`)**: Used in the reduction callback function.

These features are widely supported across modern browsers, but older versions might not support them.

**Other Alternatives**

Some alternative approaches that could be considered:

* Using `Array.prototype.filter()` on an array of keys instead of `Object.keys() + reduce()`
* Utilizing a library like Lodash or Ramda for filtering and mapping
* Employing a different data structure, such as an object with numeric keys, to optimize the filtering process

Keep in mind that these alternatives might have their own trade-offs in terms of performance, readability, and maintainability.

I hope this explanation helps you understand the benchmark!

Related benchmarks:

Object filter: fromEntries vs reduce (with keys & entries) (version: 0)

Comparing performance of: Object.fromEntries vs Object.keys + reduce vs Object.entries + reduce

Created: one year ago by: Guest

Jump to the latest result

Object.fromEntries

Object.keys + reduce

Object.entries + 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):