Numbers and BigInt in JavaScript

No matter what format you use, after compilation, these numbers will be converted into their binary format, which is a series of 1s and 0s that can be processed by computers. For example, the decimal number 5 will be converted into binary number 101.

That being said, please note that this course does not go into the details of number encoding in JavaScript. For now, you only need to understand that JavaScript numbers are encoded based on the 64-bit double-precision floating-point format, which is represented just like the scientific notation we are all too familiar with, except in binary form.

With that 64 bits, JavaScript uses 52 bits to represent the fraction, a number between 1 and 0. It then uses 11 bits for the exponent and 1 bit for the sign, either positive (1) or negative (0).

This method of number encoding does lead to some problems.

For example, in JavaScript, operations involving fractional numbers are often inaccurate. For instance, we all know 0.1 plus 0.2 equals 0.3, but when you perform that calculation using JavaScript, it gives 0.30000000000000004.

This is due to how fractional numbers are encoded.

So, the binary number 0.101 represents the decimal number 0.625.

We will not bore you with too many mathematical details here. You only need to know that most fractional numbers, when converted into binary form, will have an infinite number of digits. And since JavaScript uses limited bits to represent a number, it will have to be rounded. That's what is causing the inaccuracies.

In practice, this is not going to be too much of a problem because most tasks don't require extremely high precision. But you should treat fractional numbers as approximates, not precise numbers.

However, if you do run into such situations where the inaccuracy of fractional calculations are causing problems, you should consider multiplying the numbers to convert them into integers, and then divide.

1(0.1 * 10 + 0.2 * 10) / 10;

10.3

What is a BigInt

On the other hand, when working with integers, JavaScript is guaranteed to be accurate as long as you are working within its maximum range, which is about nine quadrillion. However, once you exceed JavaScript's capabilities, the numbers will not be represented precisely.

Although unlikely, but if you really need to work with integers larger than nine quadrillion, append the letter n to the end of the integer.

199999999999999999n;

This is called a BigInt in JavaScript. A data type similar to numbers, but it allows you to work with integers larger than nine quadrillion.

However, it is important to note that BigInt can only encode integers, not fractional numbers.

And the arithmetic operations between a number and a BigInt are forbidden.

Arithmetic operations

You can perform arithmetic operations with numbers using JavaScript.

13 + 5 * 2;

As you would have expected, multiplication and division happen before addition and subtraction. You can change the order of calculation using parentheses.

1(3 + 5) * 2;

Of course, there is also exponential, which is denoted by **.

12 ** 3; // -> 8
25 ** 2; // -> 25

Any number raised to the exponent of 0 equals 1.

12 ** 0; // -> 1
25 ** 0; // -> 1

Everything works exactly the same as what you studied in school. However, there is one operation you might not recognize, which is the modulo (%) operation. It calculates the remainder after dividing two numbers. For example:

125 % 5; // -> 0
2
325 % 10; // -> 5
4
525 % 15; // -> 10

In this case, 25 divided by 5 equals 5, with no remainder, so 25 % 5 equals 0. On the other hand, 25 divided by 10 equals 2, with 5 remaining, so 25 % 10 equals 5.

Special numbers

Besides the integers and fractional numbers, there are also two special numbers in JavaScript. The first one we must cover is NaN, which stands for "Not a Number". It has some very interesting characteristics, both as a programming concept and a mathematical concept.

First of all, "Not a Number" is a number. Strange, right? But you can verify this claim using the typeof operator.

1typeof NaN;

1number

NaN is used when an arithmetic operation that should give a number returns something that is not a number, or something that doesn't make sense. For instance, let's try to perform an arithmetic calculation on undefined, and it should give NaN.

1console.log(undefined + undefined);

1NaN

NaN is also the only value in JavaScript that does not equal itself.

1NaN == NaN; // -> false

Infinity is another special numeric value in JavaScript. It behaves just like the mathematical definition of the infinity (∞), except when the arithmetic operation generates a value that exceeds JavaScript's capabilities, the operation will also give Infinity.

110 ** 1000;

Mathematically, this should give you a number, but as we've discussed before, JavaScript can only represent 2^64 numbers, and this result exceeds that range.

Comparisons

Besides the arithmetic calculations, you can also perform comparison operations on numbers. Commonly used operators include:

• >: greater than
• <: less than
• >=: greater than or equal to
• <=: less than or equal to
• ==: equal
• !=: not equal

The result of a comparison would be a Boolean value, either true or false.

1console.log(1 > 2);
2console.log(1 < 2);
3console.log(1 >= 1);
4console.log(1 <= 2);
5console.log(1 == 1);
6console.log(1 != 1);

1false
2true
3true
4true
5true
6false

Number methods

Number methods are helper functions associated with the number type. They allow you to manipulate the numeric data without altering the original value. Here are some of the most commonly used examples:

• toString()

The toString() method is used to convert a number into a string.

1let x = 123;
2
3console.log(x.toString());
4console.log(typeof x.toString());

1123
2string

• toExponential()

toExponential() returns a string, representing the number in scientific notation.

1let x = 123;
2
3console.log(x.toExponential());
4console.log(typeof x.toExponential());

11.23e+2
2string

• toFixed()

toFixed() returns a string representing the number rounded to the specified number of decimals.

1let x = 123.12345;
2
3console.log(x.toFixed(0));
4console.log(x.toFixed(2));
5console.log(x.toFixed(4));
6console.log(x.toFixed(6));
7
8console.log(typeof x.toFixed(2));

1123
2123.12
3123.1235
4123.123450
5string

• toPrecision()

toPrecision() returns a string representing the number rounded to the specified number of digits.

1let x = 123.12345;
2
3console.log(x.toPrecision(2));
4console.log(x.toPrecision(4));
5console.log(x.toPrecision(6));
6
7console.log(typeof x.toPrecision(2));

11.2e+2
2123.1
3123.123
4string