Benchmark: Object filter: fromEntries vs reduce

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);
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
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.6 Ops/sec
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 analyze what is being tested.

**Benchmark Purpose:**
The benchmark compares two approaches for filtering an object using JavaScript:

1. `Object.fromEntries(filteredObject)`
2. `reduce()`

**Options Compared:**

*   **`Object.fromEntries(filteredObject)`**: This approach uses the `fromEntries()` method, which creates a new object from an array of key-value pairs. In this case, it's used to filter and create a new object from the filtered entries.
*   **`reduce()```**: This approach uses the `reduce()` method, a common way to iterate over arrays in JavaScript. Here, it's used to iterate over the entries and create a new object with only the desired keys.

**Pros and Cons of Each Approach:**

*   **`Object.fromEntries(filteredObject)`**:
    *   Pros:
        *   More concise and readable code
        *   Easier to understand for those familiar with `fromEntries()`
    *   Cons:
        *   Might have performance issues if the filtered object is large, as it creates a new object.
*   **`reduce()`**:
    *   Pros:
        *   Performance-friendly approach, suitable for large datasets
        *   Can be more efficient due to its built-in optimization
    *   Cons:
        *   Might require more lines of code, making it less readable

**Library Used:**
There is no specific library used in this benchmark. The `Object.entries()` and `reduce()` methods are part of the standard JavaScript API.

**Special JS Features/Syntax:**

*   None mentioned explicitly. However, keep in mind that using `Object.fromEntries()` is a relatively new feature introduced in ECMAScript 2019.

**Benchmark Preparation Code:**
The preparation code creates an array of keys (`itemsToFilter`) and another array with the same keys but filtered to only include even indices (`items`). The original object (`items`) contains these key-value pairs. This setup allows for a controlled environment to compare the two filtering approaches.

**Alternatives:**

*   Other ways to filter an object or create a new one from entries could be explored, such as using `forEach()` or other iteration methods.
*   Performance-critical applications might also consider using alternative data structures or libraries optimized for efficient filtering and aggregation.

Related benchmarks:

Object filter: fromEntries vs reduce (version: 0)

Comparing performance of: Object.fromEntries vs Reduce

Created: one year ago by: Guest

Jump to the latest result

Object.fromEntries

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