How to Handle Big Numbers in JavaScript (Integers and Floating Point)

Working with large numbers in JavaScript can be a challenge, but with the right tools and techniques, it can be done efficiently and effectively. In this article, we will explore some of the ways you can handle big numbers in JavaScript, including using the built-in BigInt data type and the popular bignumber.js library.

Working With Integers

JavaScript has a BigInt data type, which was introduced in ECMAScript 2020 (the latest version of the JavaScript language specification) to represent integers of arbitrary length. This data type can be used to represent numbers larger than the maximum safe integer (Number.MAX_SAFE_INTEGER) and is denoted by appending the n suffix to the number, like so:

const bigNumber = 123456789012345678901234567890n;
Code language: JavaScript (javascript)

The BigInt data type supports all the usual arithmetic operations, such as addition, subtraction, multiplication, and division.

It is worth mentioning that those operations can only be performed with other BigInts. You cannot multiply a BigInt by a Number, for example. You must cast the `

// Cannot mix BigInt with Numbers:

10n * 2 // Uncaught TypeError: Cannot mix BigInt and other types, use explicit conversions

// Must cast to BigInt first:

10n * BigInt(2) // 20n
10n * 2n // 20n
Code language: JavaScript (javascript)

Working with Floating Point Numbers

While the BigInt data type is useful for representing and manipulating large integers, it does not support floating point numbers (numbers with decimal places). For this, you can use the bignumber.js library, which provides a BigNumber class for representing and manipulating large numbers with arbitrary precision.

The BigNumber class has many of the same methods as the built-in Number object, such as isSafeInteger(), toString(), and toJSON(). It also has additional methods for performing advanced mathematical operations, such as calculating square roots and exponentials.

To use bignumber.js, you first need to install it using npm (the Node.js package manager):

npm install bignumber.js
Code language: CSS (css)

Once bignumber.js is installed, you can import the BigNumber class and use it like so:

const BigNumber = require('bignumber.js');

const bigNumber = new BigNumber(123.456789);

if (bigNumber.isSafeInteger()) {
  // The number is a safe integer
}
Code language: PHP (php)

BigInt vs BigNumber.js

The main difference between BigInt and BigNumber.js is that BigInt is a built-in data type in JavaScript that is used to represent integers of arbitrary length, while BigNumber.js is a library that provides a BigNumber class for representing and manipulating large numbers with arbitrary precision.

BigInt is limited to representing integers, whereas BigNumber.js can represent both integers and floating point numbers. BigInt also does not provide any advanced mathematical operations, whereas BigNumber.js has methods for performing more complex mathematical operations, such as calculating square roots.

In summary, BigInt is better suited for working with large integers, while BigNumber.js is better suited for working with both integers and floating point numbers, as well as more advanced mathematical operations.

Maximum Size of BigInt

There is no maximum value or size for a BigInt. The number will be limited by the amount of memory on the system.

How to Convert String to BigInt in JavaScript

To convert a string to a BigInt in JavaScript, you can use the BigInt() function, which is a built-in function for converting a string or number to a BigInt value.

The BigInt() function takes a string or number as an argument and returns the corresponding BigInt value.

For example, to convert the string "1234567890" to a BigInt, you can write:

const myBigInt = BigInt("1234567890"); // 1234567890n
Code language: JavaScript (javascript)

Square Root of BigInt

To calculate the square root of a BigInt value in JavaScript, you will need to use a library like bignumber.js, which provides a BigNumber class with a sqrt() method for calculating square roots.

BigInt does not have a built-in method for calculating square roots, so you must use a library like bignumber.js to perform this operation.

Here is an example of how to calculate the square root of a BigInt value using bignumber.js:

const BigNumber = require('bignumber.js');

const bigIntValue = 1234567890n;

const bigNumberValue = new BigNumber(bigIntValue.toString());
const sqrtValue = bigNumberValue.sqrt();

console.log(sqrtValue.toString()); // 1111.110101001011101110111000110101
Code language: JavaScript (javascript)

In this example, we first convert the BigInt value to a string using the toString() method. This is necessary because bignumber.js only accepts string or number values, not BigInt values. We then create a BigNumber instance from the string and use the sqrt() method to calculate the square root of the BigNumber value. Finally, we use the toString() method to convert the square root back to a string and print it to the console.

It is important to note that the square root of a BigInt value will not necessarily be a whole number, as is the case with regular JavaScript Number values. The square root of a BigInt value will be a floating point number with an arbitrary number of decimal places, so you will need to use the BigNumber class to represent and manipulate this value.

References

https://tc39.es/proposal-bigint/#sec-ecmascript-language-types-bigint-type

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt