Benchmark: lodash.compact vs js native

HTML Preparation code:

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

Script Preparation code:

var array = ['a', undefined, 'b', 1, undefined, 2, 3, undefined, undefined]

Tests:

lodash.compact
_.compact(array);
array filter
array.filter(data => { return data !== undefined && data !== null });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash.compact
array filter

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 26 days ago):

LLMs can make mistakes. Check important info.

I'll break down the benchmark and explain what's being tested, the options compared, pros and cons of each approach, and other considerations.

**Benchmark Overview**

The benchmark is comparing two approaches to remove undefined/null values from an array: Lodash's `compact` function and a native JavaScript implementation using the `filter` method.

**Lodash's `compact` Function**

The `compact` function is part of the Lodash library, which provides various utility functions for functional programming. The purpose of the `compact` function is to remove all elements from an array that are equal to undefined or null.

In this benchmark, Lodash's `compact` function is used with the following script preparation code:
```javascript
var array = ['a', undefined, 'b', 1, undefined, 2, 3, undefined, undefined];
```
The test case for Lodash's `compact` function uses the following HTML preparation code:
```html
<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>
```
**Native JavaScript Implementation**

The native JavaScript implementation uses the `filter` method to remove undefined/null values from an array. The test case for this implementation is identical to that of Lodash's `compact` function, but without the Lodash library included.

In other words, both implementations use the same input array: `['a', undefined, 'b', 1, undefined, 2, 3, undefined, undefined]`.

**Options Compared**

The two options being compared are:

1. **Lodash's `compact` function**: a third-party library that provides a pre-written implementation for removing undefined/null values from an array.
2. **Native JavaScript Implementation (using `filter` method)**: a native JavaScript implementation that uses the `filter` method to achieve the same result.

**Pros and Cons of Each Approach**

**Lodash's `compact` Function:**

Pros:

* Simplifies code by providing a pre-written implementation for a common problem.
* Often provides better performance due to optimized internal logic.

Cons:

* Requires additional library dependency (Lodash).
* May introduce overhead due to the need to load the library and perform initialization tasks.

**Native JavaScript Implementation (using `filter` method):**

Pros:

* Does not require any additional library dependencies.
* Is native code, which can result in better performance.

Cons:

* Requires manual implementation of the filtering logic, which may be more error-prone.
* May not provide the same level of optimization as Lodash's internal implementation.

**Other Considerations**

* The benchmark measures the execution time per second for each test case. This suggests that the focus is on evaluating performance and identifying any potential bottlenecks or areas for improvement.
* The use of a single input array across both implementations ensures that the comparison is fair and focused on the specific problem being addressed (removing undefined/null values from an array).
* The benchmark results can be used to compare the performance of Lodash's `compact` function against native JavaScript implementation, helping developers make informed decisions about which approach to use in their own projects.

**Alternative Implementations**

There are alternative implementations for removing undefined/null values from an array that could be explored, such as:

* Using a regex-based solution
* Utilizing the `some` and `every` methods
* Leveraging the `map` method with a callback function

However, these alternatives may not provide the same level of performance or efficiency as Lodash's `compact` function or native JavaScript implementation using the `filter` method.

Latest run results:

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

User agent: Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Mobile Safari/537.36

Browser/OS: Chrome Mobile 129 on Android

View result in a separate tab

Test name	Executions per second
lodash.compact	5170796.0 Ops/sec
array filter	1027503.4 Ops/sec

Related benchmarks:

lodash.compact vs js native (version: 0)

Remove undefined/null from array

Comparing performance of: lodash.compact vs array filter

Created: 2 years ago by: Registered User

Jump to the latest result

lodash.compact

array filter

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 26 days ago):