# The isNaN() and Number.isNaN() methods in vanilla JS

In JavaScript, `NaN` means Not A Number.

It’s often the output when trying to using number methods or math operators with things that aren’t numbers.

``````// These all return NaN
let zero = 0 / 0;
let money = parseFloat('\$\$');
let round = Math.round('42abc');
``````

However, because JavaScript is often weird, checking if a value is equal to `NaN` always validates as `false`, even if the value is `NaN`.

``````// This will log "Not NaN", which is absurd
if (NaN === NaN) {
console.log(`It's NaN!`);
} else {
console.log('Not NaN');
}
``````

JavaScript has two methods, `isNaN()` and `Number.isNaN()`, to deal with this.

## The `isNaN()` method

The `isNaN()` method is the original method for checking if something is not a number. It attempts to coerce whatever is passed in as an argument into a number, and then checks the result.

These examples were taken from MDN.

``````// These all return true
isNaN(NaN);
isNaN('NaN');
isNaN(undefined);
isNaN({});
isNaN(0 / 0);

// These all return false
isNaN(true);
isNaN(null);
isNaN(37);

// strings
isNaN('37');      // false: "37" is converted to the number 37 which is not NaN
isNaN('37.37');   // false: "37.37" is converted to the number 37.37 which is not NaN
isNaN("37,5");    // true
isNaN('123ABC');  // true:  parseInt("123ABC") is 123 but Number("123ABC") is NaN
isNaN('');        // false: the empty string is converted to 0 which is not NaN
isNaN(' ');       // false: a string with spaces is converted to 0 which is not NaN

// dates
isNaN(new Date());                // false
isNaN(new Date().toString());     // true

// This is a false positive and the reason why isNaN is not entirely reliable
// returns true
// Parsing this as a number fails and returns NaN
isNaN('blabla');
``````

MDN describes `isNaN('blabla')` returning `true` as a “false positive.” That’s odd to me. It’s not literally `NaN`, but it’s also very much not a number.

That said, I think it’s a bit confusing the `new Date()` returns `false`, but `new Date.toString()` returns `true`.

## The `Number.isNaN()` method

The `Number.isNaN()` method is a modern JS method that lacks IE support and attempts to address some of the perceived inconsistencies with how the original `isNaN()` method validates values.

``````// These all return true
Number.isNaN(NaN);
Number.isNaN(0 / 0);

// These would have been true with global isNaN()
// They return false with Number.isNaN()
Number.isNaN('NaN');
Number.isNaN(undefined);
Number.isNaN({});
Number.isNaN('blabla');
Number.isNaN(new Date().toString());

// These all return false
Number.isNaN(true);
Number.isNaN(null);
Number.isNaN(37);
Number.isNaN('37');
Number.isNaN('37.37');
Number.isNaN('');
Number.isNaN(' ');
``````

The `Number.isNaN()` method does not coerce values. As a result, things like `blabla` and `undefined`, which previously would have returned a `true` value with `isNaN()` now `return false`.

It is instead checking if the value is literally `NaN`, and nothing else.

## How do you use these methods (and which one should you use)?

You should use `Number.isNaN()`, because it literally checks if the value is `NaN` and does nothing else, which is more consistent.

Use the `Number.isNaN()` method whenever you get a value that should be a number, and are going to do some sort of math or operation with it that would break if its not.

For example, here’s a function to convert Fahrenheit to Celsius.

``````function fToC (t) {
let temp = parseFloat(t);
return (temp - 32) * (5 / 9);
}
``````

If you passed in `'32'` as a string, `parseFloat()` would convert it to the `32` and the math would work. But, if you passed in `'abc'`, it would break.

Let’s add a check using `Number.isNaN()`.

``````function fToC (t) {
let temp = parseFloat(t);
if (Number.isNaN(temp)) {
throw 'Not a valid temperature';
}
return (temp - 32) * (5 / 9);
}
``````

Now, we can preemptively catch errors.