This topic is talk about the JavaScript weird numbers that are strange sometimes. Before we starting that, do you know what is the smallest and largest representable value in JavaScript?

```
// The largest representable number
console.log(Number.MAX_VALUE); // 1.7976931348623157e+308
// The smallest representable number
console.log(Number.MIN_VALUE); // 5e-324
```

Now we can try to print the largest and smallest number can be representable value in JavaScript.

```
console.log(1.7976931348623157e+308); // 1.7976931348623157e+308
console.log(5e-324); // 5e-324
```

Cool, it seems works right? But what if we print it larger and smaller than the representable value in JavaScript?

```
console.log(1.7976931348623157e+309); // Infinity
console.log(5e-325); // 0
```

Do you see that? The output seems so weird, it can’t represent the actual number now. **JavaScript can’t represent the actual number if it over the max/min representable value. When it more than the representable value, it became INFINITY. If it less than representable value, it became 0.**

We just talked about when the numbers is exceed the representable value, it will became **Infinity** right? What if we add, minus, multiple or divide it?

```
console.log(Infinity + 5); // Infinity
console.log(Infinity - 5); // Infinity
console.log(Infinity * 5); // Infinity
console.log(Infinity / 5); // Infinity
// What if we add, minus, multiple or divide with Infinity?
console.log(Infinity + Infinity); // Infinity
console.log(Infinity - Infinity); // NaN
console.log(Infinity * Infinity); // Infinity
console.log(Infinity / Infinity); // NaN
```

In all the case above, it they remain **Infinity**. You may surprise that when** Infinity minus/divide from itself, it return will NaN.**

Now, there another case that it may become **Infinity**. **When numbers divided with 0, it became infinity.**

```
console.log(10 + 0); // 10
console.log(10 - 0); // 10
console.log(10 * 0); // 0
console.log(10 / 0); // Infinity
```

But when 0 divided with 0. It don’t return **Infinity**, it returned **NaN**.

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

Many times we think that -0 and +0 are same because when we compare both of it, it return true. But, they are doing totally different things in calculation. Let’s see how.

```
console.log(-0 === +0); // It returned true
// But, they are doing totally different things in calculation
```

Next, the we tried to divide it with negative 0 to see how the number works in JavaScript. As you can see, when **0/-0** it returned NaN.

```
console.log(0 / -0); // NaN - it returned NaN because there is no -NaN
console.log(10 / -0); // -Infinity - But in here it became negative Infinity
```

JavaScript Numbers are 64-bit Floating Point, It only able to display accurate up to 15 digits. If the number are over 15 digits, the output might be difference.

```
console.log(999999999999999); // 999999999999999
console.log(9999999999999999); // 10000000000000000
```

However, the maximum number of decimals is 17. Like any others programming languages, the floating point arithmetic is not always accurate. Try out the code below.

`console.log(0.1 + 0.2); // 0.30000000000000004`

You may be surprised that in JavaScript, 0.1 + 0.2 === 0.3 is false. Looks weird right? If you don’t believe it, just give it a try. Now we going to try it in boolean.

`0.1 + 0.2 === 0.3 // false`

Unfortunately, it doesn’t work. To learn more about it, please read this for details. https://0.30000000000000004.com/

There is also weird case when comparing to the number you should aware. Let’s look at the code here.

```
1 < 2 < 3; // True
3 > 2 > 1; // False
```

**Why it returned false when 3 > 2 > 1?**

This is because because JavaScript executes the expressions from left to right.

```
// Step 1
3 > 2 > 1;
// Step 2
true > 1;
```

In the second step, when comparing true is greater than 1, it returned false. This is because true is consider equal to 1 too.

```
true == 1; // true
true + true === 2; // true
true - true === 0; // true
```

I also experiment with the `Math.max()`

and `Math.min()`

function. It’s interesting to see the `Math.max()`

is smaller than `Math.min()`

. This is because the ** Math.max()** or

**function returns the largest/lowest value number passed in the function. If you didn’t pass any parameter, it returned**

`Math.min()`

`Infinity/-Infinity`

. If you pass the parameter isn’t a number it return **NaN**

.```
Math.max() > Math.min(); // false
Math.max() < Math.min(); // true
Math.max(); // -Infinity
Math.min(); // Infinity
```

Thanks for reading!I hope you enjoyed it, if you know something interesting too, please let me know! [email protected]