Benchmark: reduce vs filter vs for vs forin vs ternary

Script Preparation code:

var values = Array(1000).fill(['dupa', 'dupa2']).flat()

Tests:

reduce
values.reduce((prev, status) => prev + +(status === 'dupa'), 0)
filter
values.filter(status => status === 'dupa').length
for
var c = 0; for(var i = 0; i < values.length; ++i) { c += +(values[i] === 'dupa'); }
forin
var c = 0; for(var v in values) { c += +(v === 'dupa'); }
ternary
var c = 0; for(var i = 0; i < values.length; ++i) { c += values[i] === 'dupa' ? 1 : 0; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
reduce
filter
for
forin
ternary

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 dive into the world of JavaScript microbenchmarks.

**Benchmark Overview**

The provided JSON represents a benchmark test on MeasureThat.net, which compares the performance of four different approaches for filtering or accumulating data: `reduce`, `filter`, `for` (with explicit indexing), and `forin`. Additionally, there is also a comparison between a ternary operator and regular conditional statements.

**Benchmark Definitions**

The benchmark definitions are as follows:

1. **reduce**: The `reduce()` method applies a binary function to each element in an array, accumulating the result.
2. **filter**: The `filter()` method creates a new array with all elements that pass the test implemented by the provided function.
3. **for** (with explicit indexing): This approach uses a traditional `for` loop with explicit indexing to iterate over the array elements.
4. **forin**: Similar to the previous one, but uses the `for...in` loop to iterate over the object's properties (in this case, the array elements).
5. **ternary**: A ternary operator is used to conditionally assign a value based on a given expression.

**Comparison of Approaches**

Here's a brief overview of each approach:

* **reduce**: This method is often faster because it avoids creating an intermediate array and uses a single pass through the data.
* **filter**: Filtering creates an new array, which can be slower than using `reduce` or other methods that avoid this overhead. However, it provides more control over the filtering process.
* **for** (with explicit indexing): This approach is straightforward but can be slow due to the extra work involved in managing the loop counter and checking each element's index.
* **forin**: Similar to the previous one, but uses a loop that iterates over the object's properties. However, this can lead to slower performance because it may require additional work to access the array elements using their indices.
* **ternary**: This approach is simple and concise, but its performance can be limited by the overhead of evaluating conditional expressions.

**Pros and Cons**

Here are some pros and cons for each approach:

| Approach | Pros | Cons |
| --- | --- | --- |
| `reduce` | Fast, efficient | May not provide intuitive results if unfamiliar with function composition |
| `filter` | Provides control over filtering process | Creates an intermediate array, potentially slower than `reduce` or other methods |
| `for` (with explicit indexing) | Simple and straightforward | Can be slow due to extra work involved in loop counter management |
| `forin` | Easy to implement, familiar syntax for those with experience | May lead to slower performance due to accessing elements using their indices |
| **Ternary** | Concise and readable | Performance can be limited by conditional expression evaluation overhead |

**Other Considerations**

When choosing an approach, consider the following factors:

* **Readability**: If you want your code to be easy to understand for others (or yourself later), choose a method that is straightforward and concise.
* **Performance**: If speed is critical, `reduce` or other methods that avoid creating intermediate arrays may be preferable. However, if you need more control over the filtering process, `filter` might be a better choice.
* **Familiarity**: If you're familiar with function composition (e.g., `map`, `reduce`) and are comfortable working with higher-order functions, `reduce` might be an attractive option.

**Alternatives**

If you're not happy with these four approaches or want to explore other options, here are some alternative methods:

* **Map**: A method that applies a function to each element in an array, returning a new array with the results.
* **forEach**: An older, non-array-based version of `for...in` that is less common today.
* **Array.prototype.every`: A method that returns true if all elements pass a test implemented by a provided function.

Keep in mind that these alternatives might have different trade-offs in terms of performance and readability.

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/90.0.4430.85 Safari/537.36 Edg/90.0.818.46

Browser/OS: Chrome 90 on Windows

View result in a separate tab

Test name	Executions per second
reduce	152753.9 Ops/sec
filter	71787.6 Ops/sec
for	2730.9 Ops/sec
forin	13953.0 Ops/sec
ternary	2538.6 Ops/sec

Related benchmarks:

reduce vs filter vs for vs forin vs ternary (version: 0)

Comparing performance of: reduce vs filter vs for vs forin vs ternary

Created: 3 years ago by: Guest

Jump to the latest result

reduce

filter

for

forin

ternary

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