Is NaN equal to NaN?

parseFloat("NaN")

returns "NaN", but

parseFloat("NaN") == "NaN"

returns false. Now, that's probably a good thing that it does return false, but I don't understand how this is so. Did the JavaScript creators just make this a sp开发者_JAVA技巧ecial case? Because otherwise I can't understand how this returns false.

Update 2

New to ECMAScript 6 is the Object.is() function. This is designed to be a further enhancement of the === check. One of the benefits of this new function is that Object.is(NaN, NaN) will now return true. If you're able to utilize ECMAScript 6, then this would be the most readable and consistent solution for you.

Original

The proper way to check this would be:

isNaN(parseInt(variable))

If whatever you're checking is a NaN, that function will return true. This method is built into the JavaScript spec.

Using jQuery

jQuery built in their own isNaN function originally to help counter some discrepancies between browsers, and add some additional checks so their version can be used instead of the one in VanillaJS.

Update for jQuery

After jQuery 1.7, they changed this function to $.isNumeric().

Documentation of the switch

If you take a look at this Stack Overflow question, you'll find plenty of times where isNaN() returns what would intuitively be considered an "incorrect" answer, but is correct by the spec.

One of the big reasons to avoid the vanilla isNaN() is that null will return false, making you think it is a number. However, the jQuery function covers a much larger range of intuitive results.

From their documentation:

As of jQuery 3.0 $.isNumeric() returns true only if the argument is of type number, or if it's of type string and it can be coerced into finite numbers. In all other cases, it returns false.

When a JavaScript function returns NaN, this is not a literal string but an object property in the global space. You cannot compare it to the string "NaN".

See https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/NaN

It's a special case, NaN is the only thing in Javascript not equal to itself.

Although the other answers about strings vs the NaN object are right too.

NaN is one of the few examples of an object which is not equal to itself. In fact, this very property is used to implement the common bool IsNaN(number) method:

function isNaN(x)
{ 
    return x != x; 
}

isNaN works for all values that aren't numbers

isNaN('foo') == true // a string is indeed not a number
isNaN(NaN) == true
isNaN(12) == false
isNaN([1,2,3]) == true // an array is also not a number

If, however you want to check for NaN specifically, or avoid type coercion;
you can use Number.isNaN instead

Number.isNaN('foo') == false
Number.isNaN(NaN) == true
Number.isNaN(12) == false
Number.isNaN([1,2,3]) == false

• When Number (returned by ParseFloat) compares with string string converted to Number
• NaN is not equal to any other object ( including NaN)

You get NaN==NaN . It is false by second rule.

In ECMAScript 6 Object.is() is an enhancement of ===. This method accepts two arguments and returns true if the values are equivalent.And the two values are considered equivalent when they are of the same type and have the same value. That's the reason because console.log(Object.is(NaN, NaN))--> TRUE

I'm working with Google Apps Script and so I'm stuck with ECMA 5. Similar to Electric Coffee's answer, here's what I was able to figure out that seems to give a sure answer as to whether or not a value is actually NaN, not if a value is NaN but if it is actually NaN itself:

function isThisNaN(x)
{ 
    return isNaN(x) && Object.prototype.toString.call(x) === '[object Number]'; 
}
console.log(isThisNaN(NaN)); // true

lol Just funny to me that Object.prototype.toString.call(NaN) equals '[object Number]'. My newbie brain tells me that NaN is "Not a Number" but sadly it's just not that simple.

EDIT: I guess I should have said how I ended up at this article. I went with the idea that surely a string that doesn't contain a number wouldn't be treated as a number... well, I ended up finding this out:

isNaN('a'); // true
isNaN(' '); // false

so even though ' ' is a non-numerical string it apparently gets coaxed into a number (0).

console.log(Number(' ')); // 0.0

however...

console.log( 0  ? true : false); // false
console.log(' ' ? true : false); // true

After reading more I do understand it a bit better but wow what a mental crapstorm for a newbie lol