Benchmark: Nullish coalescing (??) vs logical OR (||)

Tests:

Nullish coalescing (??)
let x = null ?? undefined ?? null ?? undefined ?? null ?? undefined ?? null ?? undefined ?? null ?? undefined ?? 1;
Logical OR (||)
let x = null || undefined || null || undefined || null || undefined || null || undefined || null || undefined || 1;
Nullish coalescing (??) [short-circuit]
let x = 1 ?? undefined ?? null ?? undefined ?? null ?? undefined ?? null ?? undefined ?? null ?? undefined ?? 1;
Logical OR (||) [short-circuit]
let x = 1 || undefined || null || undefined || null || undefined || null || undefined || null || undefined || 1;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Nullish coalescing (??)
Logical OR (\|\|)
Nullish coalescing (??) [short-circuit]
Logical OR (\|\|) [short-circuit]

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**Overview of the Benchmark**

The provided benchmark compares two approaches for handling null and undefined values in JavaScript: nullish coalescing (`??`) and logical OR (`||`). Nullish coalescing is a newer feature introduced in ECMAScript 2020, while logical OR is an older operator.

**Nullish Coalescing (`??`)**

Nullish coalescing is a binary operator that returns its left operand if it's not null or undefined. If the left operand is null or undefined, the right operand is returned instead.

Example benchmark definition:
```javascript
let x = null ?? undefined ?? null ?? undefined ?? null ?? undefined ?? null ?? undefined ?? null ?? undefined ?? 1;
```
**Logical OR (`||`)**

Logical OR is a binary operator that returns its first non-false value. If both operands are false, it returns false.

Example benchmark definition:
```javascript
let x = null || undefined || null || undefined || null || undefined || null || undefined || null || undefined || 1;
```
**Comparison and Trade-Offs**

The comparison between `??` and `||` is mainly focused on their behavior when dealing with consecutive null or undefined values.

*   **Nullish Coalescing (`??`)**
    *   Pros:
        *   More intuitive and readable syntax
        *   Avoids the need to check for falsey values in a sequence of operations
        *   More efficient, as it short-circuits immediately when encountering null or undefined
    *   Cons:
        *   Less familiar syntax might require more time to learn and adopt
*   **Logical OR (`||`)**

**Logical OR (`||`) [short-circuit]**

Pros:

*   Well-established syntax that is easy to understand for most developers
*   Short-circuits immediately when encountering null or undefined

Cons:

*   Requires explicit checks for falsey values in a sequence of operations
*   Less efficient compared to `??`, as it only short-circuits after evaluating the entire sequence

**Library and Special JS Features**

The benchmark definition provided uses no external libraries. It's solely focused on demonstrating the comparison between two built-in JavaScript operators.

There are no special JavaScript features being tested or compared in this specific benchmark. However, if we were to expand the scope of the benchmark, we could explore other comparisons involving different features like `==`/`===`, `===` with object equality checks, or even more advanced topics like `try-catch` performance.

**Alternatives and Variations**

If you want to explore similar benchmarks or alternatives, consider the following:

*   Comparing the performance of different comparison operators (`==`, `===`, `!==`) or arithmetic operators (`+`, `-`, `*`)
*   Evaluating the efficiency of various methods for handling null and undefined values in a sequence (e.g., using an array to store values and then applying some operation)
*   Investigating the impact of short-circuit evaluation on different types of operations, such as arithmetic or bitwise operators
*   Comparing the performance of different programming languages that support these features, like TypeScript or C#

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36

Browser/OS: Chrome 130 on Windows

View result in a separate tab

Test name	Executions per second
Nullish coalescing (??)	4123744.5 Ops/sec
Logical OR (\|\|)	4097760.0 Ops/sec
Nullish coalescing (??) [short-circuit]	215324336.0 Ops/sec
Logical OR (\|\|) [short-circuit]	220544000.0 Ops/sec

Related benchmarks:

Nullish coalescing (??) vs logical OR (||) (version: 0)

Comparing performance of: Nullish coalescing (??) vs Logical OR (||) vs Nullish coalescing (??) [short-circuit] vs Logical OR (||) [short-circuit]

Created: 4 years ago by: Guest

Jump to the latest result

Nullish coalescing (??)

Logical OR (||)

Nullish coalescing (??) [short-circuit]

Logical OR (||) [short-circuit]

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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