Over a million developers have joined DZone.
{{announcement.body}}
{{announcement.title}}

DZone's Guide to

# NaN and Infinity in JavaScript

· Web Dev Zone ·
Free Resource

Comment (0)

Save
{{ articles[0].views | formatCount}} Views

Learn how Crafter’s Git-based content management system is reinventing modern digital experiences.

Update: New section “Detecting NaN”.

This post looks at two special values that can be the result of operations that normally return numbers: NaN and Infinity.

## 1. NaN

The value NaN in JavaScript stands for “not a number”. It mainly indicates that parsing a string has gone wrong:

```> Number("xyz")
NaN```

NaN has some Koan-like qualities. Its name is “not a number”, but it’s also not not a number (triggered by a tweet by Ariya Hidayat):

```> NaN !== NaN
true```

Yet, its type is “number”.

```> typeof NaN
'number'```

### 1.1 Detecting NaN

NaN is the only JavaScript value that is not equal to itself. Without equality at your disposal, you have to use the global function isNaN() to detect it.

```> isNaN(NaN)
true```

Kit Cambridge (via Mathias Bynens) points out a pitfall of isNaN(): It coerces its argument to number and will thus even return true for strings that cannot be converted to numbers:

```> Number("xyz")
NaN
> isNaN("xyz")
true```

For the same reason, isNaN will also return true for many objects:

```> Number({})
NaN
> isNaN({})
true

> Number(["xzy"])
NaN
> isNaN(["xzy"])
true```

Consult this previous post for details on the conversion algorithm. It is possible to override valueOf to control the result of the conversion to number:

```> var obj = { valueOf: function () { return NaN } };
> Number(obj)
NaN
> isNaN(obj)
true```

Cambridge’s suggested work-around is to exploit the fact that NaN is the only value x that is non-reflexive (x !== x):

```function myIsNaN(x) {
return x !== x;
}```

A fixed version of isNaN will probably be added to ECMAScript 6 as Number.isNaN(). Crockford’s specification of that function better reveals what one is trying to do than Cambridge’s version. It looks as follows (simplified for explanatory purposes):

```Number.isNaN = function (value) {
return typeof value === 'number' && isNaN(value);
};
```

## 2. Infinity

Division by 0 gives you another special value:

```> 3/0
Infinity```

You can’t play positive and negative infinity against each other:

```> Infinity - Infinity
NaN```

It also turns out that “ beyond infinity” is still infinity:

```> Infinity + Infinity
Infinity

> 5 * Infinity
Infinity```

Source: http://www.2ality.com/2012/02/nan-infinity.html

Crafter CMS is a modern Git-based platform for building innovative websites and content-rich digital experiences. Download this white paper now.

Topics:

Comment (0)

Save
{{ articles[0].views | formatCount}} Views

Opinions expressed by DZone contributors are their own.

### {{ parent.tldr }}

{{ parent.urlSource.name }}