Benchmark: Array filter vs. for loop - with for in 2

Script Preparation code:

var arr = [1,2,3,4,5,6,7,8,9,0], farr, i,len, el;

Tests:

Filter
farr = arr.filter(function(item) { return (item>4); });
For
for (i=0,len=arr.length;i<len;i++) { if (arr[i]<5) continue; farr.push(arr[i]); }
For 2
for (i=0,len=arr.length;i<len;i++) { if (arr[i]>4) farr.push(arr[i]); }
For in
for (i in arr) { if (arr[i]>4) farr.push(arr[i]); }
For of
for (el of arr) { if (el>4) farr.push(el); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Filter
For
For 2
For in
For of

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

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

**Benchmark Definition**

The benchmark measures the performance of different ways to filter an array in JavaScript:

1. `Array.filter()` with an anonymous function.
2. A traditional `for` loop with manual indexing (`i`) and length access (`len`).
3. A traditional `for` loop with manual indexing (`i`), but using the `in` operator to iterate over the array's elements directly.
4. An arrow function (`el of arr`) with the same filtering logic as the original `Array.filter()`.

**Options Compared**

The benchmark compares four different approaches:

1. **Anonymous Function**: Using an anonymous function within `Array.filter()`. This approach is concise and readable, but might incur some overhead due to function creation.
2. **Traditional For Loop**: Using a traditional `for` loop with manual indexing (`i`) and length access (`len`). This approach can be efficient for small arrays, but becomes cumbersome for larger datasets.
3. **For...In Loop**: Using the `in` operator in a traditional `for` loop to iterate over the array's elements directly. This approach is concise and readable, but may have performance implications due to the nature of `in` operator.
4. **Arrow Function with For...Of Loop**: Using an arrow function (`el of arr`) with a `for...of` loop to filter the array. This approach is concise and modern, but might not be supported by older browsers.

**Pros and Cons**

* **Anonymous Function (Array.filter())**: Pros: concise, readable, easy to maintain. Cons: potential overhead due to function creation.
* **Traditional For Loop**: Pros: efficient for small arrays, easy to understand. Cons: cumbersome for larger datasets, verbose code.
* **For...In Loop**: Pros: concise, readable, modern syntax. Cons: performance implications due to `in` operator behavior.
* **Arrow Function with For...Of Loop**: Pros: concise, modern, easy to read. Cons: potential compatibility issues with older browsers.

**Library Usage**

None of the benchmark cases explicitly use a JavaScript library, but some might be compatible with libraries like Lodash or Underscore.js for filtering and manipulating arrays.

**Special JS Features/Syntax**

The test case uses the following special features:

* **Arrow Functions**: Used in the "For of" loop to define the iteration logic.
* **For...Of Loops**: Used in the "For of" loop to iterate over the array's elements directly.
* **In Operator**: Used in the "For in" loop to iterate over the array's elements directly.

**Other Alternatives**

Other alternatives for filtering and manipulating arrays include:

* Using `Array.prototype.every()` or `Array.prototype.some()` instead of `Array.prototype.filter()`
* Utilizing libraries like Lodash, Underscore.js, or Ramda for array manipulation
* Employing map-reduce techniques to transform and filter data

It's worth noting that the specific performance characteristics of each approach can depend on various factors, such as the size of the input array, the target JavaScript engine, and the browser environment.

Latest run results:

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

User agent: Mozilla/5.0 (Linux; Android 5.1.1; SAMSUNG SM-P600 Build/LMY47X) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/6.2 Chrome/56.0.2924.87 Safari/537.36

Browser/OS: Chrome 56 on Android 5.1.1

View result in a separate tab

Test name	Executions per second
Filter	99463.9 Ops/sec
For	19030.5 Ops/sec
For 2	19573.4 Ops/sec
For in	26073.9 Ops/sec
For of	44798.1 Ops/sec

Related benchmarks:

Array filter vs. for loop - with for in 2 (version: 0)

This version declares i once before

Comparing performance of: Filter vs For vs For 2 vs For in vs For of

Created: 6 years ago by: Guest

Jump to the latest result

Filter

For

For 2

For in

For of

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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