Benchmark: lodash array vs array

HTML Preparation code:

<script src='https: //raw.githubusercontent.com/lodash/lodash/4.17.15-npm/core.min.js'></script>

Script Preparation code:

window.testArr = [];

for(let i = 0; i <= 100000; i++) {
    window.testArr.push(i);
}

Tests:

lodash
_.rest(window.testArr, function(num) { return i % 5 === 0; });
array
const len = window.testArr.length; for(let i = len - 1; i >= 0; i--) { if(i % 5 === 0) { window.testArr.splice(i, 1); } }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash
array

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.

Let's break down the provided benchmark definition and test cases.

**Benchmark Definition:**
MeasureThat.net is testing two approaches to remove elements from an array that meet a certain condition: using Lodash library and using native JavaScript methods (array).

The first benchmark, "_.rest(window.testArr, function(num) { return i % 5 === 0; });", uses the Lodash `rest` method, which returns all elements of the array except those for which the callback function returns a truthy value. In this case, it removes numbers that are multiples of 5.

The second benchmark, "const len = window.testArr.length; for(let i = len - 1; i >= 0; i--) { if(i % 5 === 0) { window.testArr.splice(i, 1); } }", uses native JavaScript `splice` method to remove elements from the array. It iterates through the array in reverse order and removes numbers that are multiples of 5.

**Pros and Cons:**

Lodash approach:

Pros:

* Concise and readable code
* Less error-prone due to Lodash's built-in functionality

Cons:

* Requires an additional library to be included (Lodash)
* May have performance overhead due to the need to import the library

Native JavaScript approach:

Pros:

* No additional library needed
* Potential for better performance, as native methods are often optimized for speed

Cons:

* More verbose code, which can increase complexity and error-prone
* Requires explicit handling of edge cases (e.g., checking bounds)

**Other Considerations:**

* The Lodash `rest` method is a good choice when working with large datasets, as it avoids the need to iterate through the entire array. However, it may have performance implications for very large arrays.
* The native JavaScript `splice` method can be slower for very large arrays, as it involves shifting elements to fill the gap left by the removed element.

**Library:**
The Lodash library is a popular utility library for JavaScript that provides a wide range of functions for tasks like array manipulation, string manipulation, and more. In this benchmark, the `rest` method is used to simplify the removal of elements from the array.

**Special JS Feature/Syntax:**
There are no special features or syntax used in these benchmarks, as they rely on standard JavaScript methods and Lodash library functionality.

Now, let's analyze the latest benchmark result:

The first test case for "array" shows a much higher execution rate (11773660 executions per second) compared to the "lodash" test case (0 executions per second). This suggests that native JavaScript `splice` method is faster than the Lodash `rest` method for this specific use case.

However, it's essential to note that benchmark results can vary depending on several factors, including system configuration, browser version, and array size.

Related benchmarks:

lodash array vs array (version: 0)

Comparing performance of: lodash vs array

Created: 3 years ago by: Registered User

Jump to the latest result

lodash

array

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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