Benchmark: for vs filter - MeasureThat.net

Script Preparation code:

var c = [ { id : 'abc'} , {id: 'xyz'}];
var d = [ { id:'abc'}];

Tests:

Filter
function fill(c) { return c.filter ( function(v) { for(let x=0;x<d.length;x++) { if(d[x].id == v.id){ return true } } }) } console.log(fill(c));
for loop
var zzz=[]; for(let y=0;y<d.length;y++) { let v=c[y]; for(let x=0;x<d.length;x++) { if(d[x].id == v.id){ zzz.push(v) } } } console.log(zzz);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Filter
for loop

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll break down the provided JSON and explain what's being tested, compared, and the pros/cons of each approach.

**Benchmark Definition**

The benchmark definition is a simple JavaScript function that creates two arrays, `c` and `d`, containing objects with an `id` property. The purpose of this benchmark is to compare the performance of two approaches: using the `filter()` method or a traditional `for` loop.

**Script Preparation Code**

This code snippet defines the initial state:

```javascript
var c = [
  { id: 'abc' },
  { id: 'xyz' }
];

var d = [
  { id: 'abc' }
];
```

**Html Preparation Code**

This field is empty, indicating that no HTML-specific code needs to be executed before running the benchmark.

**Individual Test Cases**

There are two test cases:

1. **Filter**

```javascript
function fill(c) {
  return c.filter(function(v) {
    for (let x = 0; x < d.length; x++) {
      if (d[x].id == v.id) {
        return true;
      }
    }
  })
}
console.log(fill(c));
```

This test case uses the `filter()` method to iterate over the `c` array and check if each object's `id` matches any object in the `d` array.

2. **for loop**

```javascript
var zzz = [];
for (let y = 0; y < d.length; y++) {
  let v = c[y];
  for (let x = 0; x < d.length; x++) {
    if (d[x].id == v.id) {
      zzz.push(v);
    }
  }
}
console.log(zzz);
```

This test case uses a traditional `for` loop to iterate over the `c` array and check if each object's `id` matches any object in the `d` array.

**Library**

The `filter()` method is a built-in JavaScript method that is part of the ECMAScript standard. Its purpose is to create a new array with all elements that pass the test implemented by the provided function.

**Special JS Feature/Syntax**

There are no special JavaScript features or syntax used in this benchmark. It's purely functional programming.

**Pros and Cons**

Here's a brief summary:

* **Filter() method:**
	+ Pros:
		- More concise and expressive
		- Built-in method, so it's likely to be optimized by the browser
		- Reduces code duplication
	+ Cons:
		- May have overhead due to function call and iteration over the array
* **Traditional `for` loop:**
	+ Pros:
		- More control over the iteration process
		- Can be optimized for specific use cases (e.g., caching)
	+ Cons:
		- More verbose code
		- May have overhead due to explicit loop iterations

**Other Alternatives**

If you want to optimize or compare these approaches, you could consider using:

* **Slices**: Instead of using `filter()` or traditional loops, you can create slices of the arrays using array methods like `slice()` or `map()`.
* **Closure-based approach**: You can use closures to create a function that iterates over one array and checks for matches in another array.
* **Native functions**: Depending on the specific use case, you might find that using native functions like `indexOf()` or `forEach()` provides better performance.

Keep in mind that the best approach depends on the specific requirements of your project.

Latest run results:

Run details: (Test run date: 9 months ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36 Edg/121.0.0.0

Browser/OS: Chrome 121 on Windows

View result in a separate tab

Test name	Executions per second
Filter	132517.7 Ops/sec
for loop	128890.8 Ops/sec

Related benchmarks:

for vs filter (version: 0)

Comparing performance of: Filter vs for loop

Created: 4 years ago by: Guest

Jump to the latest result

Filter

for loop

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