Introduction

NaN and Infinity are two numeric error values of Javascript. The way these values function may look confusing so I created this blog explaining their weird functionalities.

NaN

NaN simply means "Not a Number" and is returned by a function when it has to return a falsy number value which indicating an error.

For example,

console.log(parseInt("hello world!")); // NaN

Other than functions, NaN can be generated in many ways.
Some of the operations which can generate NaN are Infinity / Infinity, 0*Infinity, 0 * -Infinity, 1 ^ Infinity, Infinity + (-Infinity).

You can view other operations which results NaN here.

NaN is a number?

Though NaN means "Not a Number", its type in Javascript is "number"...

console.log(typeof NaN); // number

It might sound strange, but NaN is a number value that is IEEE 754 ("Not a Number" value) as stated in Annotated ES5. In simple words, NaN is also a number but it cannot expressed as a valid number. Therefore, it is called as NaN.

Identifying NaN

Another weird functionality with NaN is...

console.log(NaN === NaN); // false

Now, why NaN === NaN is false? Well, it is the only javascript value which is not equal to itself. This happens because each NaN is a unique number which cannot be represented as a valid number. So, now how to identify NaN?

For that purpose, javascript has a function named isNaN...

console.log(isNaN(NaN)); // true
console.log(isNaN(0 / 0)); // true
console.log(isNaN(1)); // false

The isNaN function will also return true for non numeric values too...
console.log(isNaN("string")); // true
// This is because Number("string") == NaN
console.log(isNaN({})); // true
// This is because Number({}) == NaN
To prevent this, you can use something like this...
const isNaNStrict = n => typeof n == "number" && isNaN(n);

Arithmetic operations with NaN

When using NaN for arithmetic operations, the result will be NaN too...

console.log(NaN + NaN); // NaN
console.log(NaN - NaN); // NaN
console.log(NaN * NaN); // NaN
console.log(NaN / NaN); // NaN

This is because "if either of the operand is NaN, the result will be NaN too" as stated in Annotated ES5.

Important Notes about NaN

NaN is a falsy value, therefore Boolean(NaN) == false.
When NaN is stringified into JSON, it is stringified into null JSON.stringify(NaN) == "null".

You can read more about NaN in Wikipedia.

Infinity

The Infinity value (represented as ∞ in mathematics) is a value returned by functions or operations when a number value is so big which the program or the computer cannot represent.

For example,

console.log(Math.pow(10, 1000)); // Infinity

Division by zero

Most of the programming languages will throw a error, when a number is divided by zero while in Javascript...

console.log(1 / 0); // Infinity

In mathematics, any number divided by zero is considered as undefined. For example, let consider 1 / 0 = x

1 / 0 = x
    1 = x * 0  ∵ Any number multiplied by zero is zero.
    1 = 0      ∴ Mathematically impossible.

So, why doesn't javascript basically returns undefined instead of Infinity. I don't consider this as a problem because in mathematics, Infinity's value is also undefined as Infinity is also mathematically impossible.

There is one exception here...

console.log(0 / 0); // NaN

It is not something very tricky, it is simply meaningless for 0 to be divided by 0 therefore the operation results a NaN value.

Negative Infinity

console.log(Infinity - Infinity); // NaN

Well, this was quite unexpected since ∞ – ∞ is undefined and javascript uses Infinity in such cases, then why the result is NaN?

This is because of the javascript compiler, a - b is considered as a + (-b), therefore Infinity - Infinity is considered as Infinity + (-Infinity) and javascript returns NaN on operations like Infinity + (-Infinity). In such cases, what can we do?

Javascript has a solution for that! And it is Number.NEGATIVE_INFINITY.

console.log(Infinity - Number.NEGATIVE_INFINITY); // Infinity
console.log(Number.NEGATIVE_INFINITY == (-Infinity)); // true

And now it looks like meaningful.

Arithmetic operations with Infinity

Here is how Infinity works with arithmetic operations.

console.log(Infinity + Infinity); // Infinity
console.log(Infinity - Infinity); // NaN
console.log(Infinity - Number.NEGATIVE_INFINITY); // Infinity
console.log(Infinity * Infinity); // Infinity
console.log(Infinity / Infinity); // NaN

Here is how Infinityand a numeric value works with arithmetic operations.

console.log(Infinity + 1); // Infinity
console.log(Infinity - 1); // Infinity
console.log(Infinity * 2); // Infinity
console.log(Infinity * 0); // NaN
console.log(1 / Infinity); // 0

Important Notes about Infinity

Infinity is a truthy value, therefore Boolean(Infinity) == true.
Though Infinity is a truthy value, when it stringified into JSON, it is stringified into null JSON.stringify(Infinity) == "null".
When Infinity is compared with any numeric value except NaN and Infinity, Infinity will be greater Infinity > 5 == true.
The parseFloat function can return Infinity as stated in the documentation while parseInt function will return NaN.
```
console.log(parseFloat('Infinity')); // Infinity
console.log(parseInt('Infinity')); // NaN
```
Unlike NaN, Infinity == Infinity will be true.

The End

If I missed to mention some functionalities of NaN or Infinity, let me know in the comments section.

If you find this blog informative,

You can follow me on Twitter.
You can follow me on GitHub.

Thank you for reading till the end!

TheSudarsanDev