Benchmark: reduce vs filter vs for vs forin vs ternary small

Script Preparation code:

var values = Array(10).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

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	6576360.5 Ops/sec
filter	5501681.5 Ops/sec
for	256222.0 Ops/sec
forin	995455.8 Ops/sec
ternary	248554.5 Ops/sec

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

LLMs can make mistakes. Check important info.

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

**Benchmark Overview**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks. The provided benchmark compares the performance of four different approaches: `reduce`, `filter`, `for` loops, and using `for...in`. Additionally, it includes a comparison with ternary expressions (`ternary`) for the same use cases.

**Tested Approaches**

1. **`reduce`**: This approach uses the `Array.prototype.reduce()` method to iterate over the array and accumulate a value.
2. **`filter`**: This approach uses the `Array.prototype.filter()` method to create a new array with elements that match a condition, and then returns the length of the resulting array.
3. **`for` loops**: These approaches use traditional `for` loops to iterate over the array elements, performing some calculations on each element.
4. **`for...in` loops**: Similar to the `for` loop, but uses the `for...in` statement to iterate over the array's properties (i.e., its elements).
5. **`ternary` expressions**: This approach uses a ternary expression (`condition ? value_if_true : value_if_false`) to perform calculations on each element.

**Pros and Cons of Each Approach**

1. **`reduce`**:
	* Pros: Efficient, concise, and easy to read.
	* Cons: May be less intuitive for beginners or those unfamiliar with the `reduce()` method.
2. **`filter`**:
	* Pros: Simple, efficient, and useful for creating new arrays.
	* Cons: Returns a new array, which may not be desirable in some cases.
3. **`for` loops**:
	* Pros: Traditional approach, easy to understand, and works with all array sizes.
	* Cons: Can be verbose, less concise than other approaches.
4. **`for...in` loops**:
	* Pros: Similar to traditional `for` loops, but can be useful for iterating over arrays in certain situations.
	* Cons: May not work as expected if the array has non-enumerable properties.
5. **`ternary` expressions**:
	* Pros: Concise and easy to read.
	* Cons: Limited to simple calculations; may become complex or hard to understand for more intricate tasks.

**Other Considerations**

* The `for...in` loop approach can be misleading, as it iterates over the array's properties (i.e., its elements), not the elements themselves. This is because the `in` operator returns a boolean indicating whether the value is an own property of the object.
* Ternary expressions are generally useful for simple conditional statements but may become cumbersome when dealing with more complex logic.

**Alternatives**

Some alternative approaches to the ones mentioned above include:

1. **`map()`**: Similar to `filter()`, but returns a new array with transformed values.
2. **`forEach()`**: A callback-based approach to iterating over arrays, similar to traditional `for` loops.
3. **`Array.prototype.every()`** and **`Array.prototype.some()`**: Methods for checking whether all or some elements in the array meet a condition.

In conclusion, each approach has its strengths and weaknesses. The choice of which one to use depends on the specific requirements and constraints of the project.

Related benchmarks:

reduce vs filter vs for vs forin vs ternary small (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 2 months ago):