**NaN** in Typescript stands for **Not a Number**. It is the result of numerical operations, where result is not a `number`

. It is the property of the global object. You can refer it either as `NaN`

or `Number.NaN`

. The `typeof`

`NaN`

is primitive `number`

. We can check whether a value is `NaN`

by using the `isNaN`

function or by `Number.IsNan`

method.

1 2 3 4 5 6 | console.log(NaN) //NaN console.log(Number.NaN) //Nan console.log(typeof(NaN)); //number |

Table of Content

## NaN

`NaN`

can happen in several ways.

- Converting an Invalid value to a number
- Dividing Zero by Zero
- Operations involving infinity
- All Operations involving NaN

### Converting an Invalid value to a number

In this following case, we are trying to convert a `string`

to a `number`

. Since “test” cannot be converted to a `number`

it results in a `NaN`

.

1 2 3 4 5 6 7 8 | let num = Number("test"); console.log(num); ***output*** NaN |

Or using an invalid value in any function that expects a number. For Example `Math.round`

or `parseInt`

methods

1 2 3 4 5 | console.log(Math.round("a")); //NaN. Typescript throws compiler error here console.log(parseInt("b")); //NaN |

Converting Undefined into a number

1 2 3 4 | let v=undefined; console.log(parseInt(v)); //NaN. Typescript throws compiler error here |

1 2 3 4 | let n = Number(undefined) console.log(n) |

### Dividing Zero by Zero

Example

1 2 3 4 5 6 7 8 9 10 | let num1 = 0/0; console.log(num1) console.log(typeof(num1)) **output** NaN number |

### Operations involving infinity

Multiply an `Infinity`

by Zero or divide `Infinity`

by Infinity will result in `NaN`

. Subtracting `Infinity`

by `Infinity`

also results in NaN.

1 2 3 4 5 | console.log(Infinity*0) console.log(Infinity/Infinity) console.log(Infinity-Infinity); |

### Operations involving NaN

All operations involving `NaN`

results in a `NaN`

.

1 2 3 4 5 6 | console.log(Number.NaN+1) console.log(Number.NaN*1) console.log(Number.NaN/1) console.log(Number.NaN-1) |

## Comparing NaN

Any comparison between the two `NaN's`

always results in `false`

. `NaN`

is never equal to itself.

1 2 3 4 5 6 7 | let n1=Number.NaN; //create a NaN let n2=n1; //make it equal console.log(n1 == n2) //false. console.log(n1 != n2) //true |

In the following example, n1 & n2 are `NaN's`

. But they are neither equal or greater or lesser from each other.

1 2 3 4 5 6 7 8 | let n1=Number.NaN; let n2=Number.NaN; console.log(n1 == n2) //false console.log(n1 > n2) //false console.log(n2 < n1) //false |

## How to check if the value is NaN

There are two ways in which we can check if the value is NaN. One is using the `isNan`

function and the other is to use the `Number.isNaN`

method.

### IsNaN

We can check whether a value is `NaN`

by using the global `IsNaN`

method.

1 2 3 | console.log(isNaN(NaN)); //true |

But, if you use this function to check a non-numeric value like `string`

. Typescript compiler throws an error here. But code compiles and `isNaN`

tries to convert the “test” into a `number`

, which results in a `NaN`

value. Hence the output is `true`

.

1 2 3 | console.log(isNaN("Test")); //true |

### Number.IsNaN

You can also use the `Number.IsNaN`

method, But it does not forcefully convert the parameter to a `number`

. If the argument is not a `number`

, then it results `false`

.

1 2 3 4 | console.log(Number.isNaN(NaN)); //true console.log(Number.isNaN("Test")); //false |

## Booleans are not NaN

Booleans are implemented as numerical values with a single binary digit (i.e., 0 & 1). Hence they are treated as numbers.

1 2 3 4 | isNaN(true); // false isNaN(false); // false |

## Summary

When a proper number cannot be the result of numerical operations, then the result is `NaN`

. For Example, converting a string to a number. `NaN`

is a primitive number. The `NaN`

can appear when you convert an Invalid value to a `number`

, Divide Zero by Zero, Some operations involving `infinity`

& all Operations involving `NaN`

, etc. You can check if the value is `NaN`

by using the method `IsNaN`

or `Number.IsNaN`