Benchmark: comparing a reduce versus a filter

Script Preparation code:

const combined = [
  {oclcNumber: 1},
  {oclcNumber: 2},
  {oclcNumber: 3},
  {oclcNumber: 4},
  {oclcNumber: 5},
  {oclcNumber: 6},
  {oclcNumber: 7},
  {oclcNumber: 8},
  {oclcNumber: 9},
  {oclcNumber: 10},
  {oclcNumber: 2},
]

Tests:

using reduce function
const combined = [ {oclcNumber: 1}, {oclcNumber: 2}, {oclcNumber: 3}, {oclcNumber: 4}, {oclcNumber: 5}, {oclcNumber: 6}, {oclcNumber: 7}, {oclcNumber: 8}, {oclcNumber: 9}, {oclcNumber: 10}, {oclcNumber: 2}, ] combined.reduce((acc, current) => { return (acc.find(record => record.oclcNumber === current.oclcNumber) ? acc : acc.concat(current)) }, [])
using filter function
const combined = [ {oclcNumber: 1}, {oclcNumber: 2}, {oclcNumber: 3}, {oclcNumber: 4}, {oclcNumber: 5}, {oclcNumber: 6}, {oclcNumber: 7}, {oclcNumber: 8}, {oclcNumber: 9}, {oclcNumber: 10}, {oclcNumber: 2}, ] combined.filter((current, i, arr) => { return arr.findIndex(record => (record.oclcNumber === current.oclcNumber)) === i })

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
using reduce function
using filter function

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 86 on Mac OS X 10.15.6

View result in a separate tab

Test name	Executions per second
using reduce function	324955.9 Ops/sec
using filter function	6743032.5 Ops/sec

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

LLMs can make mistakes. Check important info.

**Overview of the Benchmark**

The provided benchmark compares the performance of two JavaScript functions: `reduce` and `filter`. The goal is to eliminate duplicates from an array of objects.

**Library Used**

In this benchmark, no external libraries are used beyond what comes with JavaScript. However, it's worth noting that some browsers might include additional libraries or polyfills by default, which could potentially affect the results.

**Special JS Features/Syntax**

None of the provided code utilizes special JavaScript features or syntax that would affect its execution. The focus is solely on comparing the performance of two built-in functions: `reduce` and `filter`.

**Options Compared**

The benchmark compares the performance of:

1. **Reduce Function**: This function iterates over an array, reducing it to a single value (in this case, an array with unique elements). It uses the accumulator (`acc`) to keep track of seen values.
2. **Filter Function**: This function creates a new array containing only the elements that pass the test implemented by the provided function.

**Pros and Cons**

Here's a brief summary:

*   **Reduce Function:**
    *   Pros:
        *   Can be more efficient for small arrays since it only needs to keep track of seen values.
        *   Avoids creating multiple intermediate arrays, which can reduce memory usage.
    *   Cons:
        *   Can be slower for large arrays due to the need to iterate over the entire array and check for duplicates.
*   **Filter Function:**
    *   Pros:
        *   Can be faster for large arrays since it only needs to create a new array with unique elements, rather than iterating over the entire original array.
        *   More readable and maintainable, as the intent is clearer (filtering out duplicates).
    *   Cons:
        *   Creates multiple intermediate arrays, which can increase memory usage.

**Other Considerations**

*   **Time Complexity**: The reduce function has a time complexity of O(n), while the filter function also has a time complexity of O(n) on average. However, for large arrays, the filter function may still be faster due to its ability to create an array with unique elements in one pass.
*   **Memory Usage**: The reduce function typically requires less memory than the filter function because it only needs to keep track of seen values, whereas the filter function creates multiple intermediate arrays.

**Benchmark Results**

The benchmark results show that the `filter` function is faster for this specific test case on a Mac OS X 10.15.6 system with Chrome 86. The execution per second for the `using filter function` test is higher than for the `using reduce function`.

Overall, while both functions have their trade-offs, the choice between them should be based on the specific requirements of your use case. If readability and maintainability are more important than raw performance, the filter function might be a better choice. However, if you're dealing with very large arrays or need to minimize memory usage, the reduce function could be a better option.

**Alternative Approaches**

Other alternatives for eliminating duplicates from an array of objects include:

1.  **Set Data Structure**: Converting the array to a Set can provide fast lookup times and eliminate duplicates.
2.  **Array Comprehension or Mapping with a Set**: Using array comprehension or mapping functions in combination with a Set data structure can be another efficient approach.
3.  **Using `Map` and `Values()`**: Instead of using reduce, you could use Map to keep track of unique values and then access the map's values property.

Keep in mind that each approach has its own trade-offs in terms of readability, maintainability, performance, and memory usage.

Related benchmarks:

comparing a reduce versus a filter (version: 0)

when given an array of objects, which function is faster at eliminating duplicates

Comparing performance of: using reduce function vs using filter function

Created: 4 years ago by: Guest

Jump to the latest result

using reduce function

using filter function

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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