Javascript's NaN

Yet another post that underestimates the importance on NaN, it isn't 'WTF' at all if you understand its design. Sure, the naming in ES makes it a bit silly since NaN is a number, but it is something you only have to see once to understand.

Don't mess with IEEE 754, it is almost universally adopted for binary floating-point for very good reasons.

Yes, it's goofy that typeof (NaN) == 'number'. But it's not that unreasonable to have a numeric value that's explicitly invalid. Pointers and references in other languages have null, which is a legal value for any type of object, but is explicitly invalid if used as an object.

Also, isNaN is global.

One wonders if this blog post would have been written at all if the author was familiar with NaN in floating-point numbers and knew that isNaN was a thing.

isNaN is the defined method of checking if something Not A Number or can't be converted into a number.

The Real WTF (and infamous "feature" of JS) is that many things can be converted into a number.

    isNaN("string") => true
    isNaN({}) => true

but you might not expect that

    isNaN("3e2") => false
    isNaN("") => false
    isNaN([]) => false

This is hardly a JavaScript quirk. In Clojure:

    hackclj.core=> Double/NaN
    NaN
    hackclj.core=> (== Double/NaN Double/NaN)
    false
    hackclj.core=> (= Double/NaN Double/NaN) 
    false
    hackclj.core=> (.equals Double/NaN Double/NaN)
    true
    hackclj.core=> (identical? Double/NaN Double/NaN)
    false
    hackclj.core=> (type Double/NaN)
    java.lang.Double
    hackclj.core=> (number? Double/NaN)
    true

In Perl (which doesn't have a concept of a number type distinct from other scalars such as strings, but we can see that it participates in addition differently from non-numeric scalars, which behave like 0):

      DB<1> $inf = 1e300 * 1e300
    
      DB<2> $nan = $inf - $inf
    
      DB<3> print $nan
    nan
      DB<4> print ($nan == $nan)
    
      DB<5> print ref($nan)
    
      DB<6> print $nan+1   
    nan

In Ruby:

    irb(main):001:0> inf = 1e300*1e300
    => Infinity
    irb(main):002:0> nan = inf-inf
    => NaN
    irb(main):003:0> nan == nan
    => false
    irb(main):004:0> nan.class
    => Float

Python 2.7.3 (much earlier versions got equality wrong, claiming nan == nan):

    >>> inf = 1e300*1e300
    >>> nan = inf-inf
    >>> nan
    nan
    >>> nan == nan
    False
    >>> type(nan)
    <type 'float'>

Of all the things to complain about, he chose one that is not JavaScript's fault: the fact that NaN is a number and equality on NaN is not reflexive is a property of the floating point number standard.

Try it in some other language you have lying around, like Python:

    >>> type(float('nan'))
    <type 'float'>
    >>> float('nan') == float('nan')
    False

Also Haskell:

    Prelude> 0/0
    NaN
    Prelude> 0/0 == 0/0
    False

If anything, it's refreshing that JavaScript does behave like other languages in this case!

The language-agnostic way to check for NaN is to check whether x != x. Some languages might also need a type check, but AFAIK JS isn't one of them.

I wonder how many blog posts could have been avoided if Number had just been named Float instead.