Start of main content
## Recommended snippets & collections

`NaN`

(Not-a-Number) is the only JavaScript value not equal to itself when comparing with any of the comparison operators. `NaN`

is often the result of meaningless or invalid math computations, so it doesn't make sense for two `NaN`

values to be considered equal.

```
const x = Math.sqrt(-1); // NaN
const y = 0 / 0; // NaN
x === y; // false
x === NaN; // false
Number.isNaN(x); // true
Number.isNaN(y); // true
isNaN(x); // true
isNan('hello'); // true
```

You can check for `NaN`

values using the `Number.isNaN()`

function. Note that this is different from the original , global `isNaN()`

. Their difference lies in the fact that `isNaN()`

forcefully converts its argument to a number, whereas `Number.isNaN()`

doesn't. This is why `Number.isNaN()`

is considered more robust and preferable in most cases.

### JavaScript Comparison

Snippet collection

Comparing values in JavaScript is one of the most common tasks, yet it has a lot of things you should bear in mind.

### Value is string

JavaScript, Type

Checks if the given argument is a string. Only works for string primitives.

### Check object equality

JavaScript, Object

Performs a deep comparison between two values to determine if they are equivalent.

### What is the difference between JavaScript's equality operators?

JavaScript, Type

Learn all you need to know about the differences between JavaScript's double equals and triple equals operators.