Benchmark: filter-map vs reduce with object

Script Preparation code:

a = [];

for (i = 0; i < 1000; i++) {
  a.push({
    reference: !!(i % 2),
  });
}

var filtering = ({ reference }) => reference;

var mapping = (obj) => ({
  ref: obj.reference,
});

var reducing = (acc, obj) => {
  if (filtering(obj)) acc.push(mapping(obj));
  return acc;
};

Tests:

filter-map
a.filter(filtering).map(mapping);
reduce
a.reduce(reducing,[]);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
filter-map
reduce

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.90 Safari/537.36

Browser/OS: Chrome 89 on Windows

View result in a separate tab

Test name	Executions per second
filter-map	53365.6 Ops/sec
reduce	6881.9 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 test cases.

**Benchmark Overview**

The benchmark is called "filter-map vs reduce with object" and it tests two approaches to perform filtering, mapping, and reduction operations on an array of objects. The operations are performed in different orders: filter-map and reduce.

**Script Preparation Code**

The script preparation code creates an array `a` containing 1000 objects with a single property "reference" that is set to either true or false based on the remainder of the index divided by 2.

Three functions are defined:

*   `filtering`: takes an object as input and returns its "reference" property.
*   `mapping`: takes an object as input and returns a new object with an additional property "ref".
*   `reducing`: takes an accumulator array and an object as input. It checks if the filtering function is true for the object, and if so, it adds the result of mapping to the accumulator.

**Benchmark Definition**

The benchmark definition provides two test cases:

1.  **filter-map**: This test case uses the `filter()` method followed by the `map()` method on the array `a`.
2.  **reduce**: This test case uses the `reduce()` method on the array `a`.

Both tests use the same filtering and mapping functions defined in the script preparation code.

**Options Compared**

The benchmark compares two approaches:

*   **filter-map**: This approach performs filtering and mapping operations sequentially.
*   **reduce**: This approach performs both filtering and mapping operations within a single loop, using an accumulator array to store the results.

**Pros and Cons of Each Approach**

*   **Filter-Map:**
    *   Pros:
        *   Easier to understand and implement for developers familiar with `filter()` and `map()`.
        *   May be faster since filtering is performed before mapping.
    *   Cons:
        *   Can result in more memory allocations due to the creation of new arrays during mapping.
*   **Reduce:**
    *   Pros:
        *   Can reduce memory allocations by reusing the accumulator array.
        *   Allows for a single loop iteration, which can be faster than multiple loop iterations.

However, reducing performance benefits may come at the cost of additional computational complexity due to the use of an accumulator array and nested loops.

**Library and Special JS Feature**

The benchmark uses the built-in JavaScript `Array.prototype.filter()` and `Array.prototype.map()` methods. There are no external libraries used in this benchmark.

No special JavaScript features or syntax are employed in this benchmark, as it only relies on standard ECMAScript 5+ language constructs.

**Alternatives**

Other alternatives to compare with filter-map and reduce could include:

*   Using a different data structure, such as an object with methods for filtering, mapping, and reducing.
*   Implementing the operations using C++ or another compiled language, which can provide better performance but may require additional setup and maintenance.
*   Utilizing other libraries or frameworks that offer optimized implementations of filtering, mapping, and reduction operations.

Related benchmarks:

filter-map vs reduce with object (version: 0)

modified version of `map-filter vs reduce` that switches the order of operations

Comparing performance of: filter-map vs reduce

Created: 3 years ago by: Guest

Jump to the latest result

filter-map

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