# 1. The largest denominator

If you run the standard `1/0`

in Javascript, this yields the Infinity type. But what about very small denominators? If you keep making the denominator smaller, the result will obviously keep getting bigger. But when will it reach Infinity?

```
console.log(1/0);
console.log(1/0.1);
console.log(1/0.000000000000001);
console.log(1/0.0000000000000000000000000000000000000000001);
console.log(1/0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000001);
console.log(1/0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001);
console.log(1/0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001);
console.log(1/0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001);
console.log(1/0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001);
console.log(1/0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001);
console.log(1/0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001);
```

Output:

```
Infinity
10
999999999999999.9
9.999999999999999e+42
1e+85
1.0000000000000001e+304
1e+305
1e+306
1.0000000000000001e+307
1e+308
Infinity
```

So as we reach the 309th decimal place, we get Infinity. This might not be a novel revelation, because as we all may know (actually TIL) that *1.797693134862315E+308 is the limit of a floating point number*. This is also a roundabout way of asking *When does a number turn into Infinity in Javascript?*. As you would expect:

```
console.log(1e306); // 1e+306
console.log(1e307); // 1e+307
console.log(1e308); // 1e+308
console.log(1e309); // Infinity
```

# 2. Parsing Infinity

Sometimes we don't always get what we want when we parse stuff. Infinity at the least is no different. Observe:

```
parseInt(Infinity); // NaN
parseFloat(Infinity); // Infinity
```

Tada! Okay but the first line can be explained pretty easily. `parseInt`

is expecting a string type parameter, and if the argument cannot be converted into a ninteger, it returns `NaN`

. So this makes sense since `Infinity`

is not within Javascript's integer range.

However, as we've seen in the previous point, Infinity is actually represented by the `float`

type in Javascript. Hence the `parseFloat`

result makes sense!

Also, a bonus:

```
//
parseInt("Infinity", 10); // -> NaN
// ...
parseInt("Infinity", 18); // -> NaN...
parseInt("Infinity", 19); // -> 18
// ...
parseInt("Infinity", 23); // -> 18...
parseInt("Infinity", 24); // -> 151176378
// ...
parseInt("Infinity", 29); // -> 385849803
parseInt("Infinity", 30); // -> 13693557269
// ...
parseInt("Infinity", 34); // -> 28872273981
parseInt("Infinity", 35); // -> 1201203301724
parseInt("Infinity", 36); // -> 1461559270678...
parseInt("Infinity", 37); // -> NaN
```

I got that from this fun repo

# 3. Infinity is not a number, right?

Okay so without getting too much into Number Theory (I'm not even bragging, I have no idea about Number Theory), let's see how Javascript deals with Infinity as a type.

```
typeof(Infinity) // "number"
```

Okay, so it's a number. But is it?

```
1 + 1 // 2
Infinity + Infinity // Infinity
5 - 5 // 0
Infinity - Infinity // NaN
```

Wait, what? Okay speaking in Javascript terms, when you write `Infinity - Infinity`

, it is evaluated as this:

```
Infinity + (-Infinity) // NaN
```

Since `Infinity`

and `-Infinity`

are different 'objects' in Javascript, this would yield a `NaN`

. So wait, it's not a number? or is it? I actually don't know this one.

Thanks for reading!

## Top comments (0)