Benchmark: Object filtering by key

Script Preparation code:

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

Tests:

Reduce (object)
Object.keys(data) .filter(key => Number(key) % 2 === 0) .reduce((acc, key) => { acc[key] = data[key]; return acc; }, {});
Reduce (Map)
Object.keys(data) .filter(key => Number(key) % 2 === 0) .reduce((acc, key) => { acc.set(key, data[key]); return acc; }, new Map());
for-of (object)
const filter = (val) => { const result = {} for (const key in val) { if (Number(key) % 2 === 0) { continue; } result[key] = val[key]; } return result; };
for-of (Map)
const filter = (val) => { const result = new Map(); for (const key in val) { if (Number(key) % 2 === 0) { continue; } result.set(key, val[key]); } return Object.fromEntries(result.entries()); };

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Reduce (object)
Reduce (Map)
for-of (object)
for-of (Map)

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:136.0) Gecko/20100101 Firefox/136.0

Browser/OS: Firefox 136 on Windows

View result in a separate tab

Test name	Executions per second
Reduce (object)	2439.2 Ops/sec
Reduce (Map)	1638.2 Ops/sec
for-of (object)	1851825536.0 Ops/sec
for-of (Map)	1862645120.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):

LLMs can make mistakes. Check important info.

### Benchmark Overview

The benchmark on MeasureThat.net titled **"Object filtering by key"** is designed to compare different methods for filtering keys in a JavaScript object. It specifically tests various approaches for retrieving and constructing a filtered result based on whether the key (converted to a number) is even or odd.

### Options Compared

1. **Reduce with Object: `Reduce (object)`**
   - **Code**: 
     ```javascript
     Object.keys(data)
         .filter(key => Number(key) % 2 === 0)
         .reduce((acc, key) => {
           acc[key] = data[key];
           return acc;
         }, {});
     ```
   - **Description**: This method uses `Object.keys()` to extract keys from the object, `filter()` to find even keys, and `reduce()` to construct a new object.

2. **Reduce with Map: `Reduce (Map)`**
   - **Code**: 
     ```javascript
     Object.keys(data)
         .filter(key => Number(key) % 2 === 0)
         .reduce((acc, key) => {
           acc.set(key, data[key]);
           return acc;
         }, new Map());
     ```
   - **Description**: Similar to the previous method, but it constructs a `Map` instead of an object. Maps preserve the insertion order of keys, which can be beneficial.

3. **For-of Loop with Object: `for-of (object)`**
   - **Code**: 
     ```javascript
     const filter = (val) => {
       const result = {};
       for (const key in val) {
         if (Number(key) % 2 === 0) {
           continue;
         }
         result[key] = val[key];
       }
       return result;
     };
     ```
   - **Description**: This version uses a `for...in` loop directly to iterate through the object's keys to filter even ones and build a new object without additional data structures.

4. **For-of Loop with Map: `for-of (Map)`**
   - **Code**: 
     ```javascript
     const filter = (val) => {
       const result = new Map();
       for (const key in val) {
         if (Number(key) % 2 === 0) {
           continue;
         }
         result.set(key, val[key]);
       }
       return Object.fromEntries(result.entries());
     };
     ```
   - **Description**: This approach also uses a `for...in` loop but constructs a `Map` and then converts it back to an object at the end.

### Pros and Cons of Different Approaches

- **Reduce Methods (Object & Map)**:
  - **Pros**: 
    - Functional style (easier to read for those familiar with functional programming).
    - Chaining methods can be a concise way to express transformations.
  - **Cons**: 
    - May be less performant compared to other approaches due to the overhead of multiple iterations and object creation.

- **For-of Loop Methods (Object & Map)**:
  - **Pros**: 
    - More straightforward, with potentially better performance since you can build the result directly without intermediate steps.
    - Less overhead in terms of complexity since it directly works within the loop.
  - **Cons**: 
    - Slightly less idiomatic for those familiar with functional programming; might be viewed as less 'modern' by some developers.

### Other Considerations

- **Performance Data**: Based on the benchmark results, the `for-of (Map)` performed the best, followed closely by `for-of (object)`. The two `Reduce` methods were significantly slower, indicating that functional chaining can incur performance penalties due to the overhead of managing multiple intermediate steps.

- **Use of Maps**: Maps are particularly useful in scenarios where the order of keys matters or when keys are not limited to strings. They also have better performance characteristics when it comes to frequent additions and removals of key-value pairs.

### Alternatives

Other alternatives that may not have been tested include:

- Using libraries such as **Lodash**, which provides utility functions for object and array manipulations. For example, `_.pickBy()` allows for more concise filtering based on predicate functions.

- Native JavaScript features like the **spread operator** or **Object.entries()** could also be leveraged to achieve object filtering in a more modern or functional style.

In conclusion, this benchmark provides insights into the performance and usability of different methods for filtering objects in JavaScript, highlighting the trade-offs between performance, readability, and the complexity of different coding paradigms.

Related benchmarks:

Object filtering by key (version: 1)

Compares different way to filter object

Comparing performance of: Reduce (object) vs Reduce (Map) vs for-of (object) vs for-of (Map)

Created: one month ago by: Guest

Jump to the latest result

Reduce (object)

Reduce (Map)

for-of (object)

for-of (Map)

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):