Benchmark: array tests - MeasureThat.net

Script Preparation code:

  var array = [];
  for (var idx = 0; idx < 1000; idx++) {
    array[idx] = idx;
  }
  
  function oddNum(item) {
    return item % 2;
  }
  
  // Create a new array and push to it
  Array.prototype.pushFilter = function(condition) {
    // Create a new array and push to it
    var result = [],
        i, len;
    for(i = 0, len = this.length; i < len; i++) {
      if (condition(this[i], i, this)) 
        result.push(this[i]);
    }
    return result;
  };
  
  // Clone array and then remove items
  Array.prototype.spliceFilter = function(condition) {
    var result = this.slice(),
        i = result.length;
    while (i--) {
      if (!condition(result[i], i, this))
        result.splice(i, 1);
    }
    return result;
  };
  
  // Create a new array and push to it with 'this' arg
  Array.prototype.pushFilterThis = function(condition, thisArg) {
    // Create a new array and push to it
    var result = [],
        i, len;
    for(i = 0, len = this.length; i < len; i++) {
      if(condition.call(thisArg, this[i], i, this)) 
        result.push(this[i]);
    }
    return result;
  };
  
  // Clone array and then remove items with 'this' arg
  Array.prototype.spliceFilterThis = function(condition, thisArg) {
    var result = this.slice(),
        i = result.length;
    while (i--) {
      if (!condition.call(thisArg, result[i], i, this))
        result.splice(i, 1);
    }
    return result;
  };

Tests:

spliceFilterThis
var result = array.spliceFilterThis(oddNum, {});
pushFilterThis
var result = array.pushFilterThis(oddNum, {});
spliceFilter
var result = array.spliceFilter(oddNum);
filter
var result = array.filter(oddNum);
pushFilter
var result = array.pushFilter(oddNum);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
spliceFilterThis
pushFilterThis
spliceFilter
filter
pushFilter

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:99.0) Gecko/20100101 Firefox/99.0

Browser/OS: Firefox 99 on Ubuntu

View result in a separate tab

Test name	Executions per second
spliceFilterThis	14138.3 Ops/sec
pushFilterThis	100166.0 Ops/sec
spliceFilter	14205.9 Ops/sec
filter	128204.0 Ops/sec
pushFilter	122831.2 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 benchmark and explain what is being tested.

**Benchmark Overview**

The benchmark measures the performance of different array filtering methods in JavaScript: `filter`, `pushFilter`, `pushFilterThis`, `spliceFilter`, and `spliceFilterThis`. Each test case creates an array of 1000 elements, clones it, and then applies a filtering condition to remove elements that don't meet the condition.

**Test Cases**

1. `filter`: This test case uses the built-in `Array.prototype.filter()` method.
2. `pushFilter`: This test case creates a new array using the `Array.prototype.pushFilter()` method, which is not a standard JavaScript method (more on this later).
3. `pushFilterThis`: Similar to `pushFilter`, but with an additional argument (`thisArg`) that allows passing a context object.
4. `spliceFilter`: This test case uses the built-in `Array.prototype.splice()` method in conjunction with a filtering function.
5. `spliceFilterThis`: Like `spliceFilter`, but with an additional `thisArg` argument.

**Comparison**

The benchmark compares the performance of each testing method:

* `filter` and `spliceFilter` are standard JavaScript methods that are widely supported by modern browsers.
* `pushFilter` and `pushFilterThis` are not part of the standard JavaScript API. The first one is a proprietary extension, while the second one uses the `call()` method to pass a context object.

**Pros and Cons**

* **Standard Methods (filter, spliceFilter)**:
	+ Pros: Widely supported by modern browsers, easy to implement.
	+ Cons: May have performance overhead due to additional function calls.
* **Proprietary Extension (pushFilter)**:
	+ Pros: Can be faster since it doesn't involve extra function calls.
	+ Cons: Not part of the standard JavaScript API, may not work in older browsers or environments.
* **Context-Independent Method (pushFilterThis)**:
	+ Pros: Allows for more flexibility when passing context objects.
	+ Cons: May have performance overhead due to additional function calls.

**Libraries and Other Features**

In this benchmark, there is no specific library mentioned. However, if we were to analyze the `Array.prototype.pushFilter()` method, it appears to be a custom implementation that uses the `push()` method to create a new array and then filters its elements.

The test cases don't use any special JavaScript features beyond what's standard in modern browsers.

**Other Alternatives**

If you're looking for alternatives to these methods, here are some options:

* For `filter`:
	+ `Array.prototype.reduce()`: Can be used to implement filtering logic.
	+ `Array.prototype.map()`: While not designed for filtering, can be used with a conditional function.
* For `pushFilter` and `pushFilterThis`:
	+ Use the standard `Array.prototype.filter()` method instead.
* For `spliceFilter` and `spliceFilterThis`:
	+ Use the standard `Array.prototype.filter()` method instead.

Keep in mind that performance differences between these methods may vary depending on the specific use case and browser implementation.

Related benchmarks:

array tests (version: 0)

lol

Comparing performance of: spliceFilterThis vs pushFilterThis vs spliceFilter vs filter vs pushFilter

Created: 4 years ago by: Guest

Jump to the latest result

spliceFilterThis

pushFilterThis

spliceFilter

filter

pushFilter

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