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

Tests:

Boolean
[undefined, null, 1, 0, ""].filter(Boolean);
e => e
[undefined, null, 1, 0, ""].filter(e => e);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Boolean
e => e

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Linux; Android 10; MI 8 Lite) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.127 Mobile Safari/537.36

Browser/OS: Chrome Mobile 100 on Android

View result in a separate tab

Test name	Executions per second
Boolean	752206.3 Ops/sec
e => e	1648593.5 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**What is tested?**

The provided benchmark tests two approaches to filter out `undefined`, `null`, and empty strings from an array:

1. `.filter(Boolean)`: This method uses the boolean value conversion rule, where `false` is converted to 0 and any other value (including `undefined` and `null`) is converted to 0. When applied to an array, it filters out elements that are either `false`, `undefined`, or `null`.
2. `e => e`: This is an arrow function that takes each element `e` as input and returns `e`. When used with the `filter()` method, it effectively ignores any non-truthy values (i.e., `false`, `undefined`, and `null`) in the array.

**Options compared**

The benchmark compares these two approaches:

* `.filter(Boolean)`: This approach uses a more concise and arguably faster way to filter out falsy values.
* `e => e`: This approach provides more explicit control over the filtering logic, but may be slightly slower due to the arrow function overhead.

**Pros and Cons**

Here are some points to consider for each approach:

`.filter(Boolean)`

Pros:

* Concise syntax
* Potentially faster execution

Cons:

* May not be immediately clear what it's doing (requires understanding of boolean value conversion)
* May lead to unexpected behavior if used incorrectly

`e => e`

Pros:

* More explicit and readable filtering logic
* Less likely to lead to unexpected behavior due to incorrect usage

Cons:

* Slightly slower execution due to the arrow function overhead
* Requires more code to achieve the same result

**Library and syntax considerations**

In this benchmark, there is no external library used. The arrow function (`e => e`) is a modern JavaScript feature introduced in ECMAScript 2015 (ES6).

**Other alternatives**

If you need to filter out falsy values from an array, here are some alternative approaches:

* `Array.prototype.filter.call()` with a callback function: `arr.filter(call)`, where `call` is the callback function.
* Using a ternary operator: `[...].filter(e => e ? true : false)`
* Using `Array.prototype.every()`: `arr.every(e => e)`

Keep in mind that these alternatives may have different performance characteristics and readability trade-offs compared to the `.filter(Boolean)` and `e => e` approaches tested in this benchmark.

Related benchmarks:

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

Comparing performance of: Boolean vs e => e

Created: 2 years ago by: Guest

Jump to the latest result

Boolean

e => e

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):