Benchmark: isNullish variants 3

Script Preparation code:

var arr = [];
var i = 0;

while (i <= 1E5) {
    arr[i] = i % 3 === 0 ? i : i % 3 === 1 ? null : undefined

    i++;
}

Tests:

nullish coalescing
const isNullish = (value) => (value ?? true) === true; arr.forEach(i => isNullish(i));
classic
const isNullish = value => value === null || value === undefined; arr.forEach(i => isNullish(i));
classic with ==
const isNullish = value => value == null; arr.forEach(i => isNullish(i));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
nullish coalescing
classic
classic with ==

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 92 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
nullish coalescing	1255.6 Ops/sec
classic	145.2 Ops/sec
classic with ==	1230.3 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 provided benchmark and explain what's being tested.

**Benchmark Definition**

The `Script Preparation Code` part of the JSON defines the script that will be used to prepare for each test case. In this case, it's a simple JavaScript loop that generates an array `arr` with 100,000 elements. Each element is assigned a value based on its index:

- If the index is divisible by 3, the element is set to its index (i.e., `i`).
- If the index leaves a remainder of 1 when divided by 3, the element is set to `null`.
- Otherwise, the element is set to `undefined`.

**Individual Test Cases**

The test cases are designed to compare the performance of different ways to check if a value is "nullish" (i.e., either null or undefined). The values are compared using three different approaches:

1.  **Nullish Coalescing (`??` operator)**

*   **Pros**: This approach is concise and can be expressive, making it easier for developers to understand the intention behind the code. It also avoids explicit checks for `null` and `undefined`.
    *   **Cons**: The performance might not be optimal due to the overhead of evaluating the expression.
    *   **Library/Function:** Not a standard JavaScript function but introduced in ECMAScript 2020.

2.  **Classic Null Check (`value === null || value === undefined`)**

*   **Pros**: This approach is widely supported and can be more readable, especially for developers who are not familiar with the `??` operator.
    *   **Cons**: It requires explicit checks for both `null` and `undefined`, which might make the code harder to read.
3.  **Classic Null Check (`value == null`)**

*   **Pros**: This approach is concise, similar to the first option, but uses a different comparison operator (`==`) instead of the newer `===`.
    *   **Cons:** Similar to the first option, it has the potential for performance issues due to expression evaluation overhead.
4.  **Classic Null Check (without `==`)**

*   **Pros**: This approach avoids using the `==` operator and instead uses a strict equality check (`===`). It's more idiomatic JavaScript, but still may not be optimal due to expression evaluation.

**Considerations**

-   The use of the `??` operator makes the code more concise but might have performance implications.
-   Avoiding explicit checks for null and undefined can improve readability and maintainability.

**Other Alternatives (Not included in this benchmark)**

Some alternative approaches could include:

*   Using a custom function to check for nullish values.
*   Utilizing the `instanceof` operator to check if an object is a subclass of `Null` or `undefined`.
*   Implementing a custom optimization, such as using SIMD instructions (for performance-critical applications).

Keep in mind that the choice of approach should be based on factors like code readability, maintainability, and performance requirements.

Related benchmarks:

isNullish variants 3 (version: 0)

Comparing performance of: nullish coalescing vs classic vs classic with ==

Created: 3 years ago by: Guest

Jump to the latest result

nullish coalescing

classic

classic with ==

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