Benchmark: Removing element from collection

Removing element from collection (version: 0)

Comparing performance of: Array.prototype.filter vs for loop & Array.prototype.push vs _.filter with function vs _.filter with array predicate vs _.filter with object predicate vs _.remove with function vs _.remove with array predicate vs _.remove with object predicate vs Array.prototype.forEach & Array.prototype.push

Created: 8 years ago by: Guest

Jump to the latest result

HTML Preparation code:

<script src="https://rawgit.com/lodash/lodash/4.17.4/lodash.js"></script>

Script Preparation code:

var selectId = 5;

var input = [
{id:0},
{id:1},
{id:2},
{id:3},
{id:4},
{id:5},
{id:6},
{id:7},
{id:8},
{id:9}
];

Tests:

Array.prototype.filter
var output = input.filter(function(val) { return val.id == selectId; });
for loop & Array.prototype.push
var output = []; for(var i=0; i<input.length; i++) { if(input[i].id === selectId) output.push(input[i]); }
_.filter with function
var output = _.filter(input, function(val) { return val.id === selectId; });
_.filter with array predicate
var output = _.filter(input, ['id', selectId]);
_.filter with object predicate
var output = _.filter(input, {id: selectId});
_.remove with function
var output = _.remove(input, function(val) { return val.id === selectId; });
_.remove with array predicate
var output = _.remove(input, ['id', selectId]);
_.remove with object predicate
var output = _.remove(input, {id: selectId});
Array.prototype.forEach & Array.prototype.push
var output = []; input.forEach(function(val) { if (val.id === selectId) output.push(val); });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.prototype.filter
for loop & Array.prototype.push
_.filter with function
_.filter with array predicate
_.filter with object predicate
_.remove with function
_.remove with array predicate
_.remove with object predicate
Array.prototype.forEach & Array.prototype.push

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided benchmark is designed to measure the performance of removing an element from a collection in JavaScript. The test cases use different approaches, including native methods (Array.prototype.filter and Array.prototype.forEach), as well as methods from the Lodash library.

**Options Compared**

The benchmark compares six different options:

1. `_.filter(input, function(val) { return val.id === selectId; })`
2. `_.filter(input, ['id', selectId])`
3. `_.filter(input, { id: selectId })`
4. `Array.prototype.filter(input.filter(function(val) { return val.id == selectId; }))`
5. `for loop & Array.prototype.push`
6. `Array.prototype.forEach & Array.prototype.push`

**Pros and Cons**

Here's a brief summary of the pros and cons of each option:

1. **_.filter(input, function(val) { return val.id === selectId; })**
	* Pros: Simple and readable code.
	* Cons: May have performance overhead due to the use of an anonymous function.
2. **_.filter(input, ['id', selectId])**
	* Pros: Faster than option 1, since it uses a predicate array.
	* Cons: Less readable code, as the predicate is not immediately clear.
3. **_.filter(input, { id: selectId })**
	* Pros: Fast and concise code, since it uses an object literal to define the predicate.
	* Cons: May require additional setup or configuration.
4. **Array.prototype.filter()**
	* Pros: Familiar and efficient method for filtering arrays.
	* Cons: Requires creating a filtered array, which can be memory-intensive.
5. **for loop & Array.prototype.push**
	* Pros: Simple and concise code.
	* Cons: May have performance overhead due to the use of an explicit loop.
6. **Array.prototype.forEach() & Array.prototype.push**
	* Pros: Fast and efficient method for iterating over arrays.
	* Cons: Requires more boilerplate code than option 5.

**Lodash Library**

The benchmark uses the Lodash library, which provides additional utility functions for working with arrays and objects. In this case, the `_.filter()` function is used to filter the input array.

**Performance Results**

The performance results show that the fastest options are:

1. **_.filter(input, { id: selectId })**
2. **Array.prototype.filter()**
3. **_.filter(input, ['id', selectId])**

These three options consistently outperform the other three options in terms of execution speed.

**Conclusion**

In summary, this benchmark demonstrates that using Lodash's `_.filter()` function can provide significant performance benefits for filtering arrays. However, it's essential to consider code readability and maintainability when choosing a method for this task. The optimal approach will depend on specific use cases and requirements.

Related benchmarks: