Benchmark: filter vs push - MeasureThat.net

Script Preparation code:

var nums = [...(new Array(10000))].map((_, i) => i);

Tests:

for push
const result = []; for (const n of nums) { if (n%2) { result.push(n); } }
filter
const result = nums.filter(n => n&2);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
for push
filter

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36

Browser/OS: Chrome 114 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
for push	44322.1 Ops/sec
filter	45602.4 Ops/sec

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

LLMs can make mistakes. Check important info.

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

**Benchmark Definition**

The benchmark is testing two approaches to filter out odd numbers from an array: using `push()` in a loop, and using the `filter()` method.

**Script Preparation Code**

The script preparation code creates an array of 10,000 numbers, where each number is its index (`i`) in the array. This will be used as the input data for the benchmark.

**Html Preparation Code**

There is no HTML preparation code provided, which suggests that this benchmark only tests the JavaScript engine's performance and does not involve any user interface or rendering logic.

**Individual Test Cases**

The two test cases are:

1. **"for push"`**: This test case uses a loop to create an array of odd numbers by pushing each odd number onto the `result` array.
2. **"filter"`**: This test case uses the `filter()` method to create an array of odd numbers, where only numbers with a remainder of 1 when divided by 2 (`n&2 == 1`) are included in the resulting array.

**Library and Features**

There is no explicit library mentioned, but it's likely that the benchmark is using the V8 JavaScript engine or similar. The `filter()` method is a built-in JavaScript method that uses a closure to iterate over the input array.

No special JavaScript features or syntax are used beyond what's required for the benchmark itself.

**Pros and Cons of Approaches**

1. **`push()` in a loop**:
	* Pros: This approach allows the JavaScript engine to dynamically allocate memory on the heap as needed, which can be beneficial for large arrays.
	* Cons: This approach can lead to slower performance due to the overhead of pushing elements onto the stack and then allocating new memory.
2. **`filter()` method**:
	* Pros: The `filter()` method is optimized by the V8 engine and uses a more efficient algorithm that doesn't require dynamic allocation or pushing elements onto the stack.
	* Cons: This approach requires creating a new array, which can lead to increased memory usage.

Other alternatives for similar benchmarks might include:

1. **`map()` method**: Instead of using `push()` in a loop, you could use the `map()` method to create a new array with the filtered elements.
2. **Using a different data structure**: Depending on the specific requirements of the benchmark, using a different data structure (e.g., a set or an object) might provide better performance.

**Benchmark Result**

The latest benchmark result shows that the `filter()` method performed slightly better than the `push()` in a loop approach. However, this may vary depending on the specific hardware and software configuration used to run the benchmark.

Related benchmarks:

filter vs push (version: 0)

Comparing performance of: for push vs filter

Created: one year ago by: Guest

Jump to the latest result

for push

filter

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