Benchmark: isNaN vs Number.isNaN vs Object.is

Script Preparation code:

var num = Array(100).fill(0).map(v => Math.random() < 0.2 ? NaN : Math.random());

Tests:

isNaN
num.map(v => isNaN(v));
Number.isNaN
num.map(v => Number.isNaN(v))
Object.is
num.map(v => Object.is(v, NaN));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
isNaN
Number.isNaN
Object.is

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Firefox 133 on Windows

View result in a separate tab

Test name	Executions per second
isNaN	1618668.6 Ops/sec
Number.isNaN	846002.2 Ops/sec
Object.is	791726.8 Ops/sec

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

LLMs can make mistakes. Check important info.

The benchmark outlined focuses on comparing three methods for checking if a value is `NaN` (Not a Number) in JavaScript: `isNaN`, `Number.isNaN`, and `Object.is`. Each of these methods has its own characteristics and performance implications, which are valuable for developers when deciding which to use in their code.

### Benchmarked Methods

1. **isNaN(value)**:
   - **Description**: A global function that checks if a value is `NaN`. However, it performs coercion, meaning it first tries to convert the value to a number. If the value is anything other than a number, it may give misleading results. 
   - **Pros**: It may be useful for non-numeric types, as it will return true for anything that is not a number.
   - **Cons**: Its coercion can lead to unexpected results, resulting in potential bugs (e.g., `isNaN("text")` returns `true`, while other non-numeric values do not behave similarly).

2. **Number.isNaN(value)**:
   - **Description**: A method introduced in ECMAScript 2015 (ES6), `Number.isNaN` checks if a value is exactly `NaN` and does not perform type coercion.
   - **Pros**: It is safer than `isNaN`, as it only returns true if the value is of the type `Number` and is `NaN`. This reduces the chances of false positives.
   - **Cons**: As it will not accept non-number types, there might also be cases where a developer expects a broader check, yet this could handle number checks more effectively.

3. **Object.is(value1, value2)**:
   - **Description**: A method that checks for the same value or reference between two variables. This method can also be used to check if a value is `NaN`, since `Object.is(NaN, NaN)` returns true.
   - **Pros**: It provides a more general equality check that can be used for various scenarios, not limited to just checking for `NaN`. It handles `+0` and `-0` as distinct values, which may be advantageous in some contexts.
   - **Cons**: This method is more lengthy for a simple check for `NaN` and may be less intuitive for developers expecting a direct `NaN` check.

### Performance Considerations

The benchmark results show the performance of each of these methods measured in executions per second:
- `isNaN`: 167,377.53
- `Number.isNaN`: 167,090.30
- `Object.is`: 84,278.48

From the results, `isNaN` emerged as the fastest method, likely due to its simpler implementation involving type coercion. However, performance should not be the only factor when choosing which method to use.

### Other Considerations

1. **Readability**: The choice of function can affect the readability of the code. Sometimes a less performant but clearer approach may be preferred, especially for those who are reading or maintaining the code later.

2. **Future-proofing**: Using `Number.isNaN` is generally the recommended approach for many modern applications due to its clearer intent of checking for `NaN` without coercion, making it safer against potential unexpected results.

3. **Edge Cases**: Developers should consider the edge cases (like arrays, objects, or custom types) in their applications when deciding which approach to use. Depending on the context of the data that is being processed, one method may handle certain situations more appropriately than the others.

### Alternatives

If the existing methods don't suffice, developers might consider custom validation functions or utility libraries (like Lodash) which often provide extensive methods for type checking, including `_.isNaN`, although keeping a sharp focus on performance, clarity, and adherence to standards, many developers find built-in methods sufficing for most scenarios.

In summary, while performance is a consideration, selecting the right method to check for `NaN` should be based on the specific requirements of the use case, understanding the strengths and weaknesses of each approach, and aiming for code clarity and safety.

Related benchmarks:

isNaN vs Number.isNaN vs Object.is (version: 1)

Comparing performance of: isNaN vs Number.isNaN vs Object.is

Created: one month ago by: Registered User

Jump to the latest result

isNaN

Number.isNaN

Object.is

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