Benchmark: map-filter vs reduce

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)=>{
  var value=mapping(x);
  if(filtering(value)) acc.push(value);
  return acc;
}

Tests:

map-filter
a.map(mapping).filter(filtering);
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

Latest run results:

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

User agent: Mozilla/5.0 (Linux; Android 9; moto g(7)) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.136 Mobile Safari/537.36

Browser/OS: Chrome Mobile 79 on Android

View result in a separate tab

Test name	Executions per second
map-filter	3026.6 Ops/sec
reduce	1353.1 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the benchmark and explain what's being tested.

**Benchmark Purpose**

The benchmark is designed to compare the performance of two approaches: `map-filter` and `reduce`. The test case creates an array `a` with 1000 elements, each representing a fraction, and applies three functions:

1. `mapping`: adds a small value (0.1919) to each element.
2. `filtering`: checks if the result of multiplying the original element by 114514 is greater than 0.5. If true, it returns `true`.
3. `reducing`: accumulates the filtered values in an array.

The benchmark tests the performance of:

* **`map-filter`**: using `map` and then `filter`
* **`reduce`**: using a single reduction function

**Options Compared**

Two approaches are compared:

1. **`map-filter`**: combines `map` and `filter` operations.
2. **`reduce`**: uses a single reduction function to accumulate the filtered values.

**Pros and Cons of Each Approach**

* **`map-filter`**:
	+ Pros: can be more readable, easier to maintain, and allows for separate optimization of each operation.
	+ Cons: creates an intermediate array and may lead to unnecessary memory allocation.
* **`reduce`**:
	+ Pros: reduces memory allocations, as it accumulates values in a single variable. It also avoids creating an intermediate array.
	+ Cons: can be less readable, especially for complex cases.

**Library Used**

The benchmark uses the `map`, `filter`, and `reduce` functions from the JavaScript language standard library (ECMAScript). These functions are built-in and do not require any external libraries.

**Special JS Feature or Syntax**

There are no special features or syntax used in this benchmark. The code is straightforward and leverages the built-in functions mentioned earlier.

**Other Alternatives**

If you want to explore alternative approaches, consider:

1. **`forEach`**: instead of `map`, you can use a `forEach` loop with a callback function.
2. **Closures**: you could encapsulate the filtering logic within an object or function and reuse it in both `map-filter` and `reduce` approaches.
3. **Higher-order functions**: explore using other higher-order functions like `iterable#forEach()` or `Array.prototype.every()`.
4. **Native WebAssembly (WASM) implementations**: some browsers may have optimized WASM implementations for these operations.

Keep in mind that the performance differences between these alternatives might be negligible, and the benchmark should focus on measuring the performance of the specific approaches being compared (`map-filter` and `reduce`).

Related benchmarks:

map-filter vs reduce (version: 0)

Comparing performance of: map-filter vs reduce

Created: 4 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 2 months ago):