Benchmark: Lo-Dash pull vs Vanilla "remove"

HTML Preparation code:

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

Script Preparation code:

window.users = [
  { name: 'Ваня', level: '3' },
  { name: 'Саша', level: '1' },
  { name: 'Маша', level: '2' },
  { name: 'Ника', level: '3' },
  { name: 'Вера', level: '1' },
  { name: 'Саша', level: '2' },
  { name: 'Ваня', level: '2' }
];

window.toRemoveUsers = [window.users[0], window.users[3]];

Tests:

Lo-Dash pull
_.pull(users.slice(0), window.toRemoveUsers);
Vanilla "remove"
users.slice(0).filter(user => toRemoveUsers.find(x => x !== user));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lo-Dash pull
Vanilla "remove"

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 118 on Windows

View result in a separate tab

Test name	Executions per second
Lo-Dash pull	1924855.9 Ops/sec
Vanilla "remove"	743706.5 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**Benchmark Definition**

The benchmark defines two test cases:

1. **Lo-Dash pull**: This test case uses the Lodash library to remove elements from an array using `_.pull()`.
2. **Vanilla "remove"**: This test case uses only vanilla JavaScript to achieve the same result by filtering out elements that don't match the expected values.

**Options Compared**

In this benchmark, two options are being compared:

* **Lo-Dash pull**: Uses the Lodash library's `_.pull()` function, which removes all occurrences of the specified value(s) from an array.
* **Vanilla "remove"**: Uses vanilla JavaScript's `Array.prototype.filter()` method to remove elements that don't match the expected values.

**Pros and Cons**

Here are some pros and cons of each approach:

### Lo-Dash Pull

Pros:

* **Faster execution time**: Lodash provides an optimized implementation of the `_.pull()` function, which is likely faster than the vanilla JavaScript alternative.
* **Less boilerplate code**: Using a library like Lodash simplifies the code and reduces typing.

Cons:

* **Dependence on external library**: The test case relies on the Lodash library being available and correctly loaded in the browser.
* **Additional overhead**: Including an external library adds extra weight to the test, which might affect performance.

### Vanilla "Remove"

Pros:

* **No external dependencies**: This approach doesn't require loading any additional libraries, making it self-contained and potentially faster.
* **Native support**: `Array.prototype.filter()` is a native JavaScript method, so it's likely optimized for performance.

Cons:

* **More boilerplate code**: The test case requires more lines of code to achieve the same result as Lo-Dash pull.
* **Potential performance differences**: Depending on the browser and version used, the vanilla JavaScript implementation might be slower than the Lodash alternative.

**Library: Lodash**

Lodash is a popular JavaScript library that provides a collection of helper functions for common tasks, such as array manipulation. In this benchmark, Lodash's `_.pull()` function is used to remove elements from an array.

**Special JS Feature/ Syntax**

There are no special JavaScript features or syntaxes being used in this benchmark. Both test cases rely on standard JavaScript methods and libraries.

**Other Alternatives**

If you wanted to compare other alternatives for removing elements from an array, here are a few options:

* Using `Array.prototype.filter()` with a callback function: `users.slice(0).filter(user => !toRemoveUsers.includes(user))`
* Using a library like jQuery's `$().filter()` method
* Implementing your own custom array removal function using JavaScript's `forEach` and `splice` methods

However, these alternatives would likely change the test case's behavior or require additional dependencies, making them less suitable for this specific benchmark.

Related benchmarks:

Lo-Dash pull vs Vanilla "remove" (version: 0)

Comparing performance of: Lo-Dash pull vs Vanilla "remove"

Created: 4 years ago by: Guest

Jump to the latest result

Lo-Dash pull

Vanilla "remove"

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