Benchmark: filter vs compact with undefined not null

HTML Preparation code:

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

Script Preparation code:

var ops = [undefined, 1, 2, 3, 4, 5, undefined, undefined, undefined, 3, 4,5, 6, 34,341,2,2,2,1,212,21212,34,1,3112, undefined];

Tests:

lodash filter
_.filter(ops, op => op !== undefined)
lodash compact
_.compact(ops)
Native filter
ops.filter(op => op !== undefined)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash filter
lodash compact
Native filter

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36

Browser/OS: Chrome 126 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
lodash filter	514041.5 Ops/sec
lodash compact	5708967.0 Ops/sec
Native filter	573602.6 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided benchmark measures the performance of two JavaScript functions: `filter` and `compact`, from the Lodash library, versus their native implementations. The test case uses an array of undefined values, which highlights the performance differences between these functions.

**Options Compared**

There are three options compared in this benchmark:

1. **Lodash `filter` function**: This function takes a predicate as an argument and returns a new array with only the elements for which the predicate returns true.
2. **Lodash `compact` function**: This function removes all falsy values from an array, returning a new array with only the truthy values.
3. **Native filter function**: This is a custom implementation of the `filter` function using JavaScript's built-in `Array.prototype.filter()` method.

**Pros and Cons**

1. **Lodash `filter` function**:
	* Pros: Highly optimized, reliable, and widely supported.
	* Cons: External dependency on Lodash, which may introduce overhead.
2. **Lodash `compact` function**:
	* Pros: Optimized for compacting arrays, highly efficient.
	* Cons: External dependency on Lodash, which may introduce overhead.
3. **Native filter function**:
	* Pros: No external dependencies, optimized for performance.
	* Cons: Requires manual implementation of the filtering logic.

**Library and Purpose**

The `_.filter` and `_.compact` functions are part of the Lodash library, a popular JavaScript utility library. These functions provide efficient and reliable ways to manipulate arrays in various scenarios.

**Special JS Feature or Syntax**

None mentioned in this benchmark.

**Benchmark Results**

The latest benchmark results show that:

* The native filter function outperforms both Lodash implementations on the `compact` test case.
* The Lodash `filter` function is faster than the native filter function on the `filter` test case, but only by a small margin (less than 10%).
* Both Lodash functions perform similarly to each other.

**Other Alternatives**

If you don't have access to the Lodash library or prefer not to use it, you can implement similar functionality using JavaScript's built-in `Array.prototype.filter()` and `Array.prototype.includes()` methods. Additionally, you may consider using a third-party library like Ramda for functional programming utilities.

Related benchmarks:

filter vs compact with undefined not null (version: 0)

Comparing performance of: lodash filter vs lodash compact vs Native filter

Created: one year ago by: Guest

Jump to the latest result

lodash filter

lodash compact

Native filter

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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