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)