Benchmark: FilterArray - MeasureThat.net

HTML Preparation code:


<script src='https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.6.5/angular.min.js'></script>

Script Preparation code:

function filterArray(arrayToFilter, testFunction) {
                    var elementsRemoved = false;
                    var idx;

                    if (!angular.isArray(arrayToFilter) || !angular.isFunction(testFunction)) {
                        return elementsRemoved;
                    }

                    for (idx = arrayToFilter.length - 1; idx >= 0; idx--) {
                        if (!testFunction(arrayToFilter[idx])) {
                            arrayToFilter.splice(idx, 1);
                            elementsRemoved = true;
                        }
                    }

                    return elementsRemoved;
                }

var myArray = Array.apply(null, {length: 100000}).map(Function.call, Math.random);
var myFilterFunc =(x) => x > 0.5;

Tests:

FilterArray
filterArray(myArray, myFilterFunc);
Array#filter()
myArray.filter(myFilterFunc);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
FilterArray
Array#filter()

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON and explain what's being tested, the options compared, pros and cons of each approach, and other considerations.

**Benchmark Overview**

The benchmark is designed to compare two approaches for filtering an array in JavaScript: using the `filter()` method directly on the array (`Array#filter()`) versus using a custom function with the Angular framework (`filterArray()`).

**Options Compared**

1. **Direct Array Filtering (Array#filter())**: This approach uses the built-in `filter()` method of the JavaScript array prototype, which iterates over each element in the array and checks if it matches the provided condition.
2. **Angular Framework-based Filtering (filterArray())**: This approach defines a custom function that takes an array and a test function as arguments. It then iterates over each element in the array using `splice()` to remove elements that do not match the test function.

**Pros and Cons of Each Approach**

1. **Direct Array Filtering (Array#filter())**
	* Pros:
		+ Faster execution time due to optimized implementation by JavaScript engine.
		+ Less memory allocation required, as only a new array is created to store filtered elements.
	* Cons:
		+ May not work correctly for arrays with large numbers of elements or complex data structures.
2. **Angular Framework-based Filtering (filterArray())**
	* Pros:
		+ Can handle large datasets and complex data structures more efficiently.
		+ Allows for more fine-grained control over the filtering process.
	* Cons:
		+ Slower execution time due to additional overhead of Angular framework functions like `splice()`.
		+ Requires Angular framework to be loaded, which may add unnecessary overhead.

**Library and Framework**

In this benchmark, the Angular framework is used as a library to provide a way to define custom filtering functions. The `angular.isFunction()` function is used to check if the test function passed to `filterArray()` is indeed a function.

**Special JS Features or Syntax**

There are no specific JavaScript features or syntaxes being tested in this benchmark. However, it's worth noting that the use of `Function.call` with `Math.random` in the preparation code may be an example of functional programming techniques.

**Other Considerations**

* The benchmark uses a synthetic dataset (an array of 100,000 random numbers) to test the filtering performance.
* The test cases are designed to run on both desktop and mobile devices to provide more comprehensive results.

**Alternatives**

If you're interested in exploring alternative approaches for filtering arrays, consider the following:

1. **Lodash**: A popular JavaScript library that provides a `filter()` function for arrays, which can offer more flexibility and performance than the built-in `Array#filter()` method.
2. **Underscore.js**: Another JavaScript library that provides an `filter()` function for arrays, which can offer more features and customization options than the Angular framework-based approach.

Keep in mind that these alternatives may have different trade-offs in terms of execution time, memory usage, and complexity, so it's essential to evaluate them based on your specific use case and requirements.

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.77 Safari/537.36

Browser/OS: Chrome 70 on Linux

View result in a separate tab

Test name	Executions per second
FilterArray	5235.4 Ops/sec
Array#filter()	359.4 Ops/sec

Related benchmarks:

FilterArray (version: 0)

Testing if statement of filter array is in fact

Comparing performance of: FilterArray vs Array#filter()

Created: 5 years ago by: Guest

Jump to the latest result

FilterArray

Array#filter()

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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