Benchmark: For Loop VS Filter Map

Script Preparation code:

var existingEarningIds = [];

var existingEarnings = [
  {
    earningAllocation: 50,
    prospectId: "1",
    earningAllocationId: "1",
    prospectName: "Dummy",
  },
  {
    earningAllocation: 50,
    prospectId: "2",
    earningAllocationId: "2",
    prospectName: "Dummy",
  },
  {
    earningAllocation: 50,
    prospectId: "3",
    earningAllocationId: "3",
    prospectName: "Dummy",
  },{
    earningAllocation: 50,
    prospectId: "4",
    earningAllocationId: "4",
    prospectName: "Dummy",
  },{
    earningAllocation: 50,
    prospectId: "5",
    earningAllocationId: "5",
    prospectName: "Dummy",
  }
]

Tests:

For Loop
for (const earning of existingEarnings || []) { if (earning.earningAllocationId) { existingEarningIds.push(earning.earningAllocationId); } }
Filter Map
existingEarningIds = (existingEarnings || []) .filter(earning => earning.earningAllocationId) .map(earning => earning.earningAllocationId);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
For Loop
Filter Map

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/131.0.0.0 Safari/537.36

Browser/OS: Chrome 131 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
For Loop	3362569.0 Ops/sec
Filter Map	3327407.2 Ops/sec

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

LLMs can make mistakes. Check important info.

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

**Benchmark Overview**

The benchmark compares the performance of two approaches to filter and map an array of objects in JavaScript:

1. **For Loop**: A traditional for loop that iterates over the `existingEarnings` array, checks if each object has an `earningAllocationId`, and pushes the value into the `existingEarningIds` array.
2. **Filter Map**: A more concise approach using the `filter()` and `map()` methods, which are built-in JavaScript functions for filtering and mapping arrays.

**What's being tested**

The benchmark measures the execution time of each approach on various test cases. The results will show which approach is faster, typically providing insights into the trade-offs between readability, maintainability, and performance.

**Options compared**

The two options being compared are:

1. **For Loop**: A traditional iterative approach using a for loop.
	* Pros:
		+ Easy to understand and implement for developers familiar with loops.
		+ Can be more suitable for complex logic or scenarios requiring iteration control.
	* Cons:
		+ Typically slower than built-in array methods due to the overhead of explicit looping.
2. **Filter Map**: A concise approach using the `filter()` and `map()` methods.
	* Pros:
		+ Often faster due to the optimized implementation of these built-in functions.
		+ Can be more concise and expressive, making code easier to read.

**Library usage**

The benchmark uses JavaScript's built-in array methods:

1. **Array.prototype.filter()**: Removes elements from an array that don't meet a specified condition (in this case, filtering out objects without `earningAllocationId`).
2. **Array.prototype.map()**: Creates a new array with the results of applying a provided function on every element in the original array (in this case, extracting the `earningAllocationId` value from each object).

These built-in methods are part of the ECMAScript standard and are widely supported across most modern browsers.

**Special JS feature/syntax**

There is no explicit mention of special JavaScript features or syntax being used beyond the use of built-in array methods. However, it's worth noting that some modern browsers may support additional features like `for...of` loops or async/await syntax, which could potentially affect benchmark results.

**Alternatives**

Other alternatives for filtering and mapping arrays might include:

* Using a library like Lodash, which provides various utility functions for array manipulation.
* Implementing custom iteration logic using techniques like reduce() or.forEach().
* Utilizing alternative data structures, such as datasets or graphs, that might offer better performance characteristics.

Keep in mind that the choice of approach depends on the specific requirements and constraints of the project.

Related benchmarks:

For Loop VS Filter Map (version: 0)

Comparing performance of: For Loop vs Filter Map

Created: one year ago by: Guest

Jump to the latest result

For Loop

Filter Map

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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