Home Category:Javascript BigInt Support in JavaScript

BigInt Support in JavaScript

Posted on by Gaganjot Singh

JavaScript is a versatile and widely-used programming language for building websites and applications. With the rapid evolution of technology, the need for handling large integers became evident. To meet this demand, BigInt support was introduced in JavaScript.

What is BigInt?

BigInt is a numeric data type in JavaScript that provides support for integers of arbitrary length. In traditional JavaScript, numbers are represented as 64-bit binary floating-point values, which limits the range of integers that can be accurately represented. BigInts, on the other hand, can represent integers of any size without loss of precision.

How to Declare BigInts

To declare a BigInt variable in JavaScript, the BigInt function is used. Here’s an example:

const myBigInt = BigInt(12345678901234567890);

Alternatively, you can use the n suffix to indicate a BigInt literal:

const myBigInt = 12345678901234567890n;

Operations with BigInts

BigInts support all the standard arithmetic and comparison operations, just like regular numbers in JavaScript. However, keep in mind that BigInts cannot be mixed with regular numbers in arithmetic operations. You must explicitly convert regular numbers to BigInts if you need to perform operations between them.

Here’s an example of some common operations:

const x = 123n;
const y = 456n;
const sum = x + y;
const difference = x - y;
const product = x * y;
const quotient = x / y;
const modulo = x % y;
console.log(sum); // Output: 579n
console.log(difference); // Output: -333n
console.log(product); // Output: 56088n
console.log(quotient); // Output: 0n
console.log(modulo); // Output: 123n

Converting BigInts to Regular Numbers

Sometimes, you may need to convert a BigInt back to a regular number. JavaScript provides a couple of ways to achieve this:

  • Using the Number function: Although this method can cause loss of precision for large BigInts, it is useful for converting small BigInts back to regular numbers.
const bigInt = 123n;
const regularNumber = Number(bigInt);

console.log(regularNumber); // Output: 123
  • Using the BigInt.prototype.valueOf method: This method returns the primitive value of a BigInt without loss of precision.
const bigInt = 123n;
const regularNumber = bigInt.valueOf();

console.log(regularNumber); // Output: 123

Useful Methods for BigInts

BigInts come with several built-in methods that allow you to manipulate and perform operations with them. Here are a few examples:

  • toString(): Converts a BigInt to a string representation.
const bigInt = 12345678901234567890n;
const string = bigInt.toString();
console.log(string); // Output: "12345678901234567890"
  • BigInt.asUintN(bitLength): Returns a BigInt which is the input modulo 2 raised to the power of bitLength.
const bigInt = BigInt.asUintN(32, 1234567890n);
console.log(bigInt); // Output: 1234567890n
  • BigInt.asIntN(bitLength): Returns a BigInt which is the input modulo 2 raised to the power of bitLength, with its sign preserved.
const bigInt = BigInt.asIntN(32, -1234567890n);
console.log(bigInt); // Output: -1234567890n

Browser Compatibility

It’s important to note that BigInts are not supported in all browsers. As of now, BigInts are supported in modern browsers such as Chrome, Firefox, Edge, and Safari. However, if your target audience includes users with older browsers, it is recommended to check for BigInt support or consider alternative approaches.

Conclusion

BigInt support in JavaScript has greatly expanded the capabilities of working with large integers. Whether you need to perform complex calculations or handle scenarios that demand precision, BigInts provide a reliable solution. As browser compatibility improves, BigInts will become more prevalent in web development. So, embrace this powerful feature and leverage its capabilities in your JavaScript projects!

Leave a Reply