Benchmark: filter(Boolean) vs. filter(a => a)

Script Preparation code:

window.list = [];
for (let i = 0; i < 65536; i++) {
    window.list.push(Math.random() > 0.5 ? 1 : 0);
}

Tests:

filter(Boolean)
list.filter(Boolean);
filter(a => a)
list.filter(a => a);
filter(a => !!a)
list.filter(a => !!a)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
filter(Boolean)
filter(a => a)
filter(a => !!a)

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

MeasureThat.net provides a platform for users to create and run JavaScript microbenchmarks. The benchmark in question is designed to test the performance of two different approaches: `filter(Boolean)` vs. `filter(a => a)`. Both methods are used to remove empty elements from an array.

**Tested Options**

The following options are compared:

1. **`list.filter(Boolean)`**: This method uses the `Boolean()` function to filter out falsey values (including 0, "", [], etc.). It is equivalent to `filter(a => a)` but has some performance benefits.
2. **`list.filter(a => a)`**: This method uses an arrow function to filter out only the elements that are truthy.

**Pros and Cons of Each Approach**

1. **`list.filter(Boolean)`**:
	* Pros: Typically faster than `filter(a => a)` due to the use of `Boolean()` which is optimized for performance.
	* Cons: May not be as readable or maintainable, especially for complex filtering logic.
2. **`list.filter(a => a)`**:
	* Pros: More readable and maintainable, as it clearly conveys the intention of filtering out only truthy values.
	* Cons: May be slower than `filter(Boolean)` due to the overhead of evaluating the arrow function.

**Library and Purpose**

The `Boolean()` function is a built-in JavaScript function that converts its argument to a boolean value. It is used here to filter out falsey values from the array.

**Special JS Feature or Syntax**

None mentioned in this benchmark, but it's worth noting that some modern browsers support `BigInt` literals, which allow for arbitrary-precision integers. However, this feature is not relevant to the current benchmark.

**Other Alternatives**

If you want to explore other filtering methods, here are a few alternatives:

* Using `Array.prototype.filter()` with a callback function: `list.filter(function(a) { return !!a; })`
* Using `Array.prototype.map()` and then applying the `Array.prototype.filter()` method: `list.map(function(a) { return !!a; }).filter(function(a) { return a; })`

Keep in mind that these alternatives may have different performance characteristics compared to the original methods.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:77.0) Gecko/20100101 Firefox/77.0

Browser/OS: Firefox 77 on Windows

View result in a separate tab

Test name	Executions per second
filter(Boolean)	564.7 Ops/sec
filter(a => a)	495.6 Ops/sec
filter(a => !!a)	458.4 Ops/sec

Related benchmarks:

filter(Boolean) vs. filter(a => a) (version: 0)

Removing empties

Comparing performance of: filter(Boolean) vs filter(a => a) vs filter(a => !!a)

Created: 4 years ago by: Registered User

Jump to the latest result

filter(Boolean)

filter(a => a)

filter(a => !!a)

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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