Benchmark: lodash pull vs native splice

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/npm/lodash@4.17.21/lodash.min.js"></script>

Script Preparation code:

var max = 10000000; // 10,000,000 (10 Million)

var arr = [];
for (var i = 0; i <= max; i++) { arr.push(i); }

Tests:

lodash
_.pull(arr, 890047);
native
const index = arr.indexOf(890047); if (index >= 0) arr.splice(index, 1);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash
native

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/134.0.0.0 Safari/537.36

Browser/OS: Chrome 134 on Windows

View result in a separate tab

Test name	Executions per second
lodash	112.0 Ops/sec
native	303.3 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Explanation**

The provided JSON represents two test cases for measuring the performance of JavaScript arrays using different approaches: `_.pull` from Lodash and native `splice` method.

**Options Compared**

Two options are being compared:

1. **Lodash's `_pull` method**: This is a utility function from the Lodash library that removes all elements from an array that pass a test.
2. **Native JavaScript `splice` method**: This is a built-in method of JavaScript arrays that allows removing elements at a specified index.

**Pros and Cons**

### _.pull (Lodash)

Pros:

* Easy to use: The function takes a callback as an argument, which specifies the conditions for removal.
* Concise code: The implementation is simple and efficient.

Cons:

* External dependency: Lodash needs to be included in the project, adding extra size and potential download times.
* Performance impact: Creating a new array with only the desired elements might incur additional memory allocation costs.

### Native JavaScript `splice` method

Pros:

* No external dependencies: Built-in functions are faster and more efficient since they don't require additional overhead like loading libraries.
* Memory-efficient: Only modifies the original array, avoiding unnecessary allocations.

Cons:

* Less intuitive for simple removals: Requires indexing or using methods like `indexOf` to find and remove elements.

**Library: Lodash**

Lodash is a popular JavaScript library that provides a comprehensive set of functional programming utilities. In this case, `_pull` is used to simplify array manipulation by removing specific elements based on a condition. The inclusion of Lodash adds extra size to the benchmark but offers an easy-to-use solution for array modifications.

**Special JS feature or syntax**

Neither test case uses any special JavaScript features or syntax beyond standard ECMAScript 2020 (ES2020) features, ensuring compatibility across different browsers and platforms.

**Alternative approaches**

Other alternatives for removing elements from arrays in JavaScript include:

1. **Array.prototype.filter()**: Returns a new array with only the elements that pass the test provided by the callback function.
2. **Array.prototype.map()`: Creates a new array with the results of applying the provided mapping function to each element.
3. **Set data structure**: Using `Set` can be more efficient for unique values or when performance is critical, but may not be suitable for all use cases.

These alternatives might offer trade-offs in terms of memory usage, execution speed, or code readability, making them worth considering depending on the specific requirements and constraints of your project.

Related benchmarks:

lodash pull vs native splice (version: 0)

Comparing performance of: lodash vs native

Created: 4 years ago by: Guest

Jump to the latest result

lodash

native

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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