Benchmark: compact function

HTML Preparation code:

<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.js"></script>

Script Preparation code:

var array = [undefined, 'cat', false, 434, '', 32.0]

Tests:

_.compact(array)
_.compact(array)
array.filter(Boolean)
array.filter(Boolean)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
_.compact(array)
array.filter(Boolean)

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 5 years ago)

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

Browser/OS: Chrome 73 on Mac OS X 10.14.3

View result in a separate tab

Test name	Executions per second
_.compact(array)	3934647.2 Ops/sec
array.filter(Boolean)	2415950.2 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the provided JSON for MeasureThat.net and explain what's being tested.

**Benchmark Definition**

The benchmark definition is a JavaScript function that tests two different approaches to removing falsy values from an array.

1. **_.compact(array)**: This test uses the Lodash library, specifically the `compact` function. The purpose of this function is to create a new array with all elements removed that are falsy (i.e., null, undefined, 0, false, etc.).

2. **array.filter(Boolean)**: This is a built-in JavaScript method that returns a new array containing only the elements in the original array for which the expression passed to `filter` returns `true`. In this case, we're using `Boolean()` as the callback function to filter out falsy values.

**Options Compared**

The two options being compared are:

1. Using Lodash's `compact` function.
2. Using the built-in JavaScript method `array.filter(Boolean)`.

**Pros and Cons**

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

Pros:

* Easy to use: simply pass an array to the `compact` function.
* Well-tested and maintained library.

Cons:

* Requires including Lodash in your project, which may add unnecessary bundle size.
* May have performance overhead due to the need for a separate library.

**Built-in JavaScript Method `array.filter(Boolean)`**

Pros:

* No additional library required, reducing bundle size.
* Optimized for performance by leveraging native JavaScript execution.

Cons:

* Requires understanding of the filter method and its callback function.
* May be less readable than using Lodash's `compact` function due to its concise syntax.

**Other Considerations**

When choosing between these two approaches, consider the following factors:

* Readability: If you prefer a more explicit and readable code, `array.filter(Boolean)` might be a better choice. However, if brevity is important or you're working in a context where Lodash is already included, `_._compact(array)``` might be more suitable.
* Performance: Both approaches have similar performance characteristics, but the built-in JavaScript method may have a slight edge due to its native execution.
* Maintenance and Updates: Since this is a built-in JavaScript method, it will receive updates and bug fixes directly from Mozilla. Lodash's `compact` function, on the other hand, relies on community-driven maintenance.

**Special JS Feature or Syntax**

There are no special JavaScript features or syntaxes being used in these tests. The code only employs standard JavaScript features like arrays, functions, and built-in methods.

**Alternatives**

If you're interested in exploring alternative approaches to removing falsy values from an array, consider the following:

1. `Array.prototype.filter`: This is a similar method to `array.filter(Boolean)`, but without the `Boolean()` wrapper.
2. Using a custom function or regex pattern to achieve the same result.

Example of using a custom function:
```javascript
function compact(array) {
  return array.reduce((acc, current) => acc.includes(current) ? acc : acc.concat([current]), []);
}
```
Keep in mind that this approach may have performance implications due to the use of `reduce` and explicit checks.

Related benchmarks:

compact function (version: 0)

Comparing performance of: _.compact(array) vs array.filter(Boolean)

Created: 5 years ago by: Registered User

Jump to the latest result

_.compact(array)

array.filter(Boolean)

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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