Strange code in jQuery sources: var !== var ? x : y;
I'm piggy-backing on some of the comments here, but think this worthy information.
Some comments on the original question have suggested that this method of checking for NaN is actually much faster than isNaN()
When taken in conjunction with the following alternative to parseInt
parseFloat
we have a very fast way of converting to a number and checking its numeric state.
Is Subtracting Zero some sort of JavaScript performance trick?
So instead of
function Translated(val) {
var x = parseFloat(val);
if (!isNaN(x)) {
alert("Not a number");
}
}
We can have
function WTF(val) {
var x = val - 0;
if (x !== x) {
alert("Not a number");
}
}
In fact it is written in the comment right above:
// NaN means non-codepoint
So it is mandatory to perform this comparison first to handle the NaN
case as in JavaScript:
NaN === NaN
returns false
.
As pointed out by James Wiseman it is also important to know why the developer used high !== high
instead of isNaN(high)
which would have been clearer.
It is certainly based on performance. This test shows that a !== a
is twenty times faster than isNaN(a)
.
zzzzBov also indicates that isNaN()
could be overwritten, using !==
is also more portable.
More info from Benjamin Gruenbaum:
It is also worth noting that NaN does not equal to anything else as well, and also it is not equal to anything else in an unstrict sense
And from Jan Dvorak:
Also note
{valueOf:function(){return{}}}
does equal itself
The condition high !== high
returns true, when high is NaN
.I wonder why the jQuery guys did not used the much clear isNaN(high)
function instead, but that was probably due to performance reasons as koopajah pointed out.
NaN
(N
ot-a
-N
umber) means a result that cannot be represented as a Number
. It is an undeterminated number.
Why NaN === NaN returns false ?
Consider
0/0 = NaN
Math.asin(2) = NaN
You know that 0/0
is different than Math.asin(2)
, so why whould NaN
be equal to NaN
?