Toggle navigation
MeasureThat
.net
Create a benchmark
Tools
Feedback
FAQ
Register
Log In
Array remove
(version: 2)
Comparing performance of:
Using filter vs Using while loop
Created:
2 years ago
by:
Registered User
Go to the latest result
Tests:
Using filter
const data = [...Array(1000).keys()] data.filter(n => n % 2 === 0)
Using while loop
const arrayRemove = function(array, predicate){ let i = -1, len = array ? array.length : 0; const result = []; while (++i < len) { const value = array[i]; if (predicate(value, i, array)) { result.push(value); Array.prototype.splice.call(array, i--, 1); len--; } } return result; }; const data = [...Array(1000).keys()] arrayRemove(data, n => n % 2 === 0)
Rendered benchmark preparation results:
Suite status:
<idle, ready to run>
Run tests (2)
Previous results
Fork
Test case name
Result
Using filter
Using while loop
Fastest:
N/A
Slowest:
N/A
Latest run results:
Run details:
(Test run date:
2 years ago
)
User agent:
Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36
Browser/OS:
Chrome 125 on Windows
View result in a separate tab
Embed
Embed Benchmark Result
<iframe src="https://measurethat.net/Embed?id=526124" width="100%" height="500px"></iframe>
Using filter
53K/s
Using while loop
13K/s
View exact numbers
Test name
Executions per second
✓
Using filter
52,673 Ops/sec
Using while loop
13,121 Ops/sec
Autogenerated LLM Summary
(model
llama3.2:3b
, generated one year ago):
Let's break down the provided benchmark and explain what's being tested. **Benchmark Overview** The benchmark measures the performance of two approaches to remove even numbers from an array: 1. Using the `filter()` method 2. Using a custom `arrayRemove` function with a while loop **Options Compared** The two options being compared are: * **Using filter()**: This approach uses the built-in `filter()` method of JavaScript arrays, which iterates over each element in the array and applies a predicate (a function that returns a boolean value) to determine whether to include or exclude the element. * **Using while loop**: This approach uses a custom implementation with a while loop that manually iterates over the array elements, removing even numbers from the original array. **Pros and Cons of Each Approach** 1. **Using filter():** * Pros: + Concise and readable code + Built-in method provides a familiar interface for developers + Optimized for performance by using native JavaScript implementation * Cons: + May have higher overhead due to the creation of a new array with filtered elements + Limited control over iteration order (elements are processed in ascending order) 2. **Using while loop:** * Pros: + Provides fine-grained control over iteration order and indexing + Can be optimized for specific use cases or hardware architectures * Cons: + More verbose code compared to using `filter()` + Requires manual management of array indices, which can lead to bugs **Library and Purpose** In the provided benchmark, no explicit libraries are used. However, JavaScript's built-in `Array.prototype.filter()` method is being utilized. **Special JS Features or Syntax** The custom `arrayRemove` function uses some advanced JavaScript features: 1. **Arrow functions**: The predicate function passed to `filter()` and the callback function in `splice()` use arrow functions (`n => n % 2 === 0`, `(value, i, array) => true`) to provide concise code. 2. **Spread operator**: The spread operator (`[...Array(1000).keys()]`) is used to create a new array with 1000 elements. **Other Alternatives** If you were to implement an alternative approach to remove even numbers from an array, some options might include: 1. **Using `every()` and `map()`**: Instead of using `filter()`, you could use the `every()` method to check if all elements in a new array meet a condition (e.g., not being even) and then use `map()` to create a new array with only the odd numbers. 2. **Using `reduce()`**: You could also use `reduce()` to iterate over the array, accumulate an array of odd numbers, and return the result. These alternative approaches would likely have similar performance characteristics to the ones being tested in the benchmark, but might require more code or be less efficient due to additional overhead from method calls.
Related benchmarks
Remove by splice vs copyWithin vs filter vs delete
Comments
Confirm delete:
Do you really want to delete benchmark?