Benchmark: filter-map vs reduce, fixed.

Script Preparation code:

a=[];
for(i=0;i<1000;i++) a.push(Number(i)/1000);

var filtering=x=>(x*114514)%1>0.5;
var mapping=x=>x+0.1919;

var reducing=(acc,x)=>{
  if((x*114514)%1>0.5) acc.push(x+0.1919);
  return acc;
}

Tests:

map-filter
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
map-filter
reduce

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what's being tested.

**Benchmark Overview**

The provided JSON represents a JavaScript microbenchmark that compares two approaches: `filter-map` and `reduce`. The benchmark is modified to switch the order of operations, which makes it a variation of the original "map-filter vs reduce" benchmark.

**Script Preparation Code**

The script preparation code defines three functions:

1. `filtering(x)`: takes an input `x`, multiplies it by 114514, and checks if the result is greater than 0.5 modulo 1 (i.e., a non-integer value). If true, returns whether the original value plus 0.1919 is greater than 0.5.
2. `mapping(x)`: takes an input `x` and returns the result of adding 0.1919 to it.
3. `reducing(acc, x)` : accumulates values in `acc`, pushing new values when the filtering condition is met.

**Html Preparation Code**

There is no HTML preparation code provided, which means that the benchmark does not take into account any DOM-related overhead or asynchronous operations.

**Options Compared**

The two options being compared are:

1. **Filter-Map**: This approach uses `Array.prototype.filter()` to filter out elements that don't meet the filtering condition, followed by `Array.prototype.map()` to apply the mapping function to the remaining elements.
2. **Reduce**: This approach uses `Array.prototype.reduce()` to accumulate values in an accumulator array, applying the reduction function to each element in turn.

**Pros and Cons**

1. **Filter-Map**
	* Pros:
		+ Easier to understand for developers familiar with the `filter()` and `map()` methods.
		+ Can be more intuitive for developers who are already comfortable with using these methods.
	* Cons:
		+ May incur overhead due to the additional method calls (two operations: filtering and mapping).
2. **Reduce**
	* Pros:
		+ More efficient, as it avoids the overhead of separate `filter()` and `map()` method calls.
		+ Can be more effective for accumulating values in an array, especially when dealing with large datasets.
	* Cons:
		+ May require more understanding of the reduction function and its side effects (e.g., modifying the accumulator).

**Library: Lodash**

The `reduce` option uses the `reduce()` method from the Lodash library. This is a popular utility library that provides additional functional programming helpers, including `reduce()`. The use of Lodash here allows for a more concise implementation of the reduction function.

**Special JS Feature or Syntax**

There are no special JavaScript features or syntax being used in this benchmark.

**Other Considerations**

The benchmark measures the number of executions per second (ExecutionsPerSecond) for each browser, which provides a relative performance comparison. However, keep in mind that this measurement can be influenced by various factors, such as:

* Browser version and configuration
* System resources (CPU, memory)
* Network latency and overhead

**Alternatives**

If you're interested in exploring alternative approaches or libraries, here are some options to consider:

1. **Array.prototype.every()` instead of `filter()`: This method returns a boolean indicating whether all elements in the array pass the test.
2. **Array.prototype.forEach()` with custom filtering: Instead of using `filter()` and then `map()`, you could use `forEach()` and apply custom filtering logic within the callback function.
3. **Underscore.js or other libraries**: Explore alternative utility libraries that provide similar functionality to Lodash, such as `underscore.js` or `ramda`.

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.27 Safari/537.36

Browser/OS: Chrome 96 on Linux

View result in a separate tab

Test name	Executions per second
map-filter	39927.4 Ops/sec
reduce	59824.3 Ops/sec

Related benchmarks:

filter-map vs reduce, fixed. (version: 0)

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

Comparing performance of: map-filter vs reduce

Created: 3 years ago by: Guest

Jump to the latest result

map-filter

reduce

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