Toggle navigation
MeasureThat
.net
Create a benchmark
Tools
Feedback
FAQ
Register
Log In
redcue vs flatMap
(version: 0)
Comparing performance of:
Reduce vs flatMap
Created:
2 years ago
by:
Guest
Go to the latest result
Script Preparation code:
var arr = Array(10_000).fill(0)
Tests:
Reduce
arr.reduce((acc, x) => [...acc, x], [])
flatMap
arr.flatMap(x => x)
Rendered benchmark preparation results:
Suite status:
<idle, ready to run>
Run tests (2)
Previous results
Fork
Test case name
Result
Reduce
flatMap
Fastest:
N/A
Slowest:
N/A
Latest run results:
Run details:
(Test run date:
2 years ago
)
User agent:
Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:120.0) Gecko/20100101 Firefox/120.0
Browser/OS:
Firefox 120 on Windows
View result in a separate tab
Embed
Embed Benchmark Result
<iframe src="https://measurethat.net/Embed?id=488048" width="100%" height="500px"></iframe>
flatMap
14K/s
Reduce
3/s
View exact numbers
Test name
Executions per second
✓
flatMap
13,583 Ops/sec
Reduce
3 Ops/sec
Autogenerated LLM Summary
(model
llama3.2:3b
, generated one year ago):
Let's break down what's being tested in this benchmark. **Overview** The benchmark compares the performance of two approaches: `reduce` and `flatMap`. Both methods are used to transform an array, but they differ in how they handle the accumulation of values. **Options compared** Two options are compared: 1. **`arr.reduce((acc, x) => [...acc, x], [])`**: This method applies a callback function to each element in the array, accumulating the results in an accumulator (`acc`). The callback returns a new array by spreading the current accumulator (`[...acc, x]`) and appending the current element (`x`). Finally, the original array is returned. 2. **`arr.flatMap(x => x)`**: This method applies a callback function to each element in the array, returning a new array with the results of the callback applied to each element. **Pros and Cons** 1. **`reduce`**: * Pros: More memory-efficient, as it only accumulates values in an accumulator. * Cons: Can be slower for large arrays due to the overhead of the callback function and accumulator updates. 2. **`flatMap`**: * Pros: Faster for large arrays, as it avoids the need for accumulator updates and can utilize hardware acceleration (e.g., SIMD instructions). * Cons: More memory-intensive, as it creates a new array with all intermediate results. **Library** None of the test cases use any external libraries. The benchmarks only rely on built-in JavaScript features. **Special JS feature or syntax** The `flatMap` method uses a special syntax called "arrow functions" (e.g., `(x) => x`). This is a shorthand way to define small, single-expression functions in JavaScript. Arrow functions are supported by most modern browsers and Node.js versions. **Other alternatives** For transforming arrays, other options include: 1. **`map()`**: Similar to `flatMap`, but returns an array of transformed values without accumulating intermediate results. 2. **`forEach()`**: Executes a callback function for each element in the array, but does not return any value (i.e., it's more like a side effect). 3. **`for...of` loops**: Can be used to iterate over arrays and accumulate values in variables. Note that these alternatives may have different performance characteristics compared to `reduce` and `flatMap`. The choice of which method to use depends on the specific use case and performance requirements.
Related benchmarks
flatMap vs flat+map
Reduce Push vs. flatMap with subarrays
flat() vs flatMap()
flatMap vs flat+map 2
Comments
Confirm delete:
Do you really want to delete benchmark?