Understand the difference between isNaN and Number.isNaN

Before we take a dive into the difference between isNaN and Number.isNaN, let's take a look at what NaN is

According to the javascript spec NaN stands for Not a Number, when you encounter something like this in javascript, you will have to cross check what you are trying to do it's either

1. you are trying to carry out an invalid mathematical operation or
2. you are trying to cast something that's not a number (except for a string of numbers) to a number for example

parseInt('hello'); // a string of characters cannot be converted to a number therefore the operation will return NaN

Number(undefined); // NaN

'string'/2; // NaN

One thing you have to know is that you cannot compare NaN to NaN or Number.NaN, therefore

parseInt('hello world') === parseInt('hello world'); // false

So you know, this does not have to do with strict equality comparison or abstract equality comparison

parseInt('foo') == parseInt('foo'); // false

But you can actually make a check for the above with Object.is

Object.is(parseInt('foo'), parseInt('foo')); // true
Object.is(NaN, NaN); // true

Apart from using Object.is , you can also check if a value is NaN, which can be done with

1. isNaN // on the global object
2. Number.isNaN

Which ever one you choose will determine how you will get backstabbed by javascript.
So this bring us to the difference between isNaN and Number.isNaN

isNaN does two things

1. It checks if the value passed to it is NaN or
2. It will try to coerce the passed value into a number if the result is NaN then the return value will be true

Number.isNaN does only one thing

1. It checks if the current value passed in actually NaN

for example

isNaN('javascript'); // true
The reason for this is because isNaN coerces 'javascript' to a number and since javascript is not a number the return value is false

Number.isNaN('javascript'); // false
The reason for this is because 'javascript' is a string and not the value NaN, so the return value will be false

isNaN(NaN); // true
NaN is not a number hence true

Number.isNaN(NaN); // true
NaN is not a number hence true

What you should get from the above is that Number.isNaN does not do any form of coercion, it just check if the value passed to it is NaN, if it's not NaN then the return value will be false.

Open to corrections, this is my first ever article. Thanks for reading