Benchmark: typeof number vs. Number.isNan vs. isNan vs self comparison. Versus let

Script Preparation code:

var a = 5

Tests:

typeof
typeof a === 'number'
Number.isNan
Number.isNaN(a)
isNaN
isNaN(a)
Self comparison
a !== a

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
typeof
Number.isNan
isNaN
Self comparison

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 120 on Windows

View result in a separate tab

Test name	Executions per second
typeof	15785600.0 Ops/sec
Number.isNan	6374537.5 Ops/sec
isNaN	6455585.0 Ops/sec
Self comparison	8503222.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON and explain what is being tested, compared, and considered in this JavaScript microbenchmark.

**Benchmark Definition**

The benchmark measures the performance of four different approaches to compare the value `a` with itself:

1. `typeof a === 'number'`
2. `Number.isNaN(a)`
3. `isNaN(a)`
4. `a !== a` (self-comparison)

These tests are compared to determine which one is the most efficient.

**Options Compared**

The options being compared have pros and cons:

* `typeof a === 'number'`: This approach checks if the type of `a` is `'number'`, which can be expensive due to the overhead of the `typeof` operator. However, it's a straightforward and concise way to check.
* `Number.isNaN(a)`: This function is specifically designed to test for NaN (Not a Number) values. It's more efficient than `typeof` because it uses an internal optimization to avoid unnecessary checks. On the other hand, it only checks for NaN, not all number types.
* `isNaN(a)`: This function checks if the value of `a` is NaN. While it's faster than `Number.isNaN`, it has a broader scope and may return incorrect results for non-NaN numbers.
* `a !== a`: This self-comparison approach is the simplest and most efficient, as it only requires comparing the value with itself. However, it may not be suitable for all use cases, especially if you're working with complex data structures.

**Library Usage**

In this benchmark, the `Number.isNaN` function from the JavaScript standard library is used to test for NaN values. This function is specifically designed to provide a fast and efficient way to check for NaNs.

**Special JS Feature/Syntax**

There are no special JavaScript features or syntax being tested in this benchmark. The tests only use built-in functions and variables.

**Other Considerations**

* The benchmark is running on a Chrome browser with version 120, which may affect the results due to changes in the engine's behavior.
* The executions per second (EPS) values indicate the number of times each test was executed within a second. A higher EPS value typically indicates better performance.
* The `DevicePlatform` and `OperatingSystem` fields are likely used for device-specific optimizations or statistical analysis.

**Alternatives**

If you were to implement this benchmark yourself, some alternative approaches could be:

* Using `Number.EPSILON` instead of `isNaN(a)` to check for very small values
* Implementing a custom NaN test using bitwise operations (e.g., `a === 0 && a + 1 !== a`)
* Adding additional tests for other number types, such as BigInt or complex numbers
* Optimizing the benchmark for specific use cases or browsers

Keep in mind that this is just a microbenchmark, and the results may not be representative of real-world performance. The goal is to provide insights into the relative efficiency of different approaches, rather than to optimize performance for a particular use case.

Related benchmarks:

typeof number vs. Number.isNan vs. isNan vs self comparison. Versus let (version: 0)

Comparing performance of: typeof vs Number.isNan vs isNaN vs Self comparison

Created: one year ago by: Guest

Jump to the latest result

typeof

Number.isNan

isNaN

Self comparison

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