Benchmark: typeof undefined vs falsey/truthy

Script Preparation code:

const undef = undefined
function checkIsUndefined(val) {
  return typeof val === 'undefined'
}
function checkIsNotUndefined(val) {
  return typeof val !== 'undefined'
}
function checkIsTruthy(val) {
  return !!val
}
function checkIfFalsey(val) {
  return !val
}

Tests:

typeof val === 'undefined'
checkIsUndefined(undef)
typeof val !== 'undefined'
checkIsNotUndefined(undef)
!!val
checkIsTruthy(undef)
!val
checkIfFalsey(undef)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
typeof val === 'undefined'
typeof val !== 'undefined'
!!val
!val

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one month ago)

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

Browser/OS: Chrome 129 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
typeof val === 'undefined'	9744942.0 Ops/sec
typeof val !== 'undefined'	9913581.0 Ops/sec
!!val	10258979.0 Ops/sec
!val	10022835.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):

LLMs can make mistakes. Check important info.

The benchmark represents a comparison between different approaches for checking the state of a variable in JavaScript, specifically whether a variable is `undefined` or if it is "truthy" or "falsy." The test cases evaluate the performance of different expressions using a predefined variable, `undef`, assigned the value of `undefined`.

### Options Tested

1. **Checking for `undefined` Using `typeof`**:
   - **Test Name**: `typeof val === 'undefined'`
   - **Test Name**: `typeof val !== 'undefined'`
   - **Description**: These tests check if the variable is `undefined` or not using the `typeof` operator.

2. **Checking Truthiness/Falsiness**:
   - **Test Name**: `!!val`
   - **Test Name**: `!val`
   - **Description**: These tests determine the truthy or falsy value of the variable by coercing it to a Boolean. The `!!` operator converts the value to a Boolean (returning `true` for truthy values and `false` for falsy ones), while `!` checks if the value is falsy, returning `true` for falsy values and `false` otherwise.

### Pros and Cons of Each Approach

1. **Using `typeof`:**
   - **Pros**:
     - Safe: The `typeof` operator is safe and won’t throw an error if the variable doesn't exist, unlike direct access which may generate a ReferenceError.
     - Clear intent: It explicitly communicates that the check is meant to determine if a variable is `undefined`.
   - **Cons**:
     - Performance: The use of `typeof` can be slightly slower than direct truthiness checks because it evaluates the variable’s type.

2. **Using Truthiness/Falsiness Checks:**
   - **Pros**:
     - Performance: In this benchmark, operations like `!!` and `!` appear to be faster than `typeof`, which is indicated by higher execution rates in the test results.
     - Conciseness: These expressions are generally shorter and can be more readable in contexts where you are checking for truthiness.
   - **Cons**:
     - Ambiguity: Using truthiness checks can yield unexpected results if the variable can hold other falsy values (e.g., `0`, `""`, `NaN`), which may not be the intended check for `undefined`.

### Benchmark Results

The results show the number of executions per second for each test case:

- `!!val`: 10,258,979 executions/second (fastest)
- `!val`: 10,022,835 executions/second
- `typeof val !== 'undefined'`: 9,913,581 executions/second
- `typeof val === 'undefined'`: 9,744,942 executions/second (slowest)

### Considerations

When choosing an approach, it is essential to consider the context. If the primary goal is to check if a variable is `undefined`, using `typeof` is clear and safe. However, in cases where checking for truthy or falsy values suffices, using `!!` or `!` may be optimal regarding performance.

### Alternatives

Other alternatives to check for `undefined` could include:

- Direct comparison: `val === undefined` or `val !== undefined`. This is straightforward but should be avoided if you want to prevent reference errors for undeclared variables.
- Nullish Coalescing Operator (`??`): This operator can be used in conjunction with checks to provide default values when the variable is `null` or `undefined`, although it's not directly comparable in terms of performance.

In conclusion, the choice between these methods often boils down to the context of usage, desires for code clarity, and acceptable performance trade-offs.

Related benchmarks:

typeof undefined vs falsey/truthy (version: 1)

which is faster

Comparing performance of: typeof val === 'undefined' vs typeof val !== 'undefined' vs !!val vs !val

Created: one month ago by: Guest

Jump to the latest result

typeof val === 'undefined'

typeof val !== 'undefined'

!!val

!val

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):