# BigInt in JavaScript

Miscellaneous: BigInt

### What is BigInt in JavaScript?​

Interview Response: BigInt is a built-in object in JavaScript that allows the representation of integers with arbitrary precision, beyond the limit of the Number type, for computations that require high precision.

Technical Response: BigInt is a unique numeric type that allows integers of any length. A BigInt gets formed by attaching n to the end of an integer literal or by using the BigInt function, which generates BigInts from strings, numbers. BigInt gets used chiefly as a regular integer. All operations on BigInts return BigInts. BigInts and regular numbers cannot be blended. If necessary, we should explicitly convert them using BigInt() or Number(). The conversion procedures are always quiet and never produce errors, but if the BigInt is too huge, it won’t fit the number type, and excess bits get chopped off; thus, we should exercise caution while doing such conversions.

Code Example:

``const bigint = 1234567890123456789012345678901234567890n;const sameBigint = BigInt('1234567890123456789012345678901234567890');const bigintFromNumber = BigInt(10); // same as 10nconsole.log(1n + 2n); // 3console.log(5n / 2n); // 2console.log(1n + 2); // Error: Cannot mix BigInt and other typeslet bigint = 1n;let number = 2;// number to bigintconsole.log(bigint + BigInt(number)); // 3// bigint to numberconsole.log(Number(bigint) + number); // 3``

### How do you declare a BigInt in JavaScript?​

Interview Response: You can declare a BigInt by appending 'n' to the end of an integer or by using the BigInt constructor with a number or string as argument.

Code Example:

``const bigint = 1234567890123456789012345678901234567890n;const sameBigint = BigInt('1234567890123456789012345678901234567890');const bigintFromNumber = BigInt(10); // same as 10n``

### Why was BigInt introduced in JavaScript?​

Interview Response: BigInt was introduced to handle large numbers which are beyond the safe integer limit for Numbers in JavaScript. This is useful in cryptography, finance, and other number-heavy computations.

### Can you perform mathematical operations with BigInts and Numbers together?​

Interview Response: No, you cannot directly perform operations between BigInts and Numbers. You must convert them to the same type before performing operations.

Code Example:

``const myBigInt = BigInt("12345678901234567890");const myNumber = 10;const result = Number(myBigInt) + myNumber;console.log(result); // 12345678901234567000``

### How does the division operator interact with BigInts?​

Interview Response: In JavaScript, the division operator with BigInts truncates any fractional part, always resulting in a BigInt, unlike division with Numbers which can yield fractional results.

Code Example:

``// Regular Numbersconsole.log(5 / 2); // 2.5// BigIntconsole.log(5n / 2n); // 2, rounds towards zero``

### How does BigInt handle decimal numbers?​

Interview Response: BigInt only represents whole numbers. Decimals are not supported and will cause a SyntaxError.

Code Example:

``const myBigInt = BigInt(3.14159);console.log(myBigInt); // RangeError: The number 3.14159 cannot be converted to a BigInt because it is not an integerconst anotherBigInt = BigInt("2.71828");console.log(anotherBigInt); // SyntaxError: Cannot convert 2.71828 to a BigInt``

### Can BigInt be used as a key in a Map or Set?​

Interview Response: Yes, BigInt can be used as a key in a Map or Set in JavaScript.

Code Example:

Here's an example of using BigInt as a key in a `Map`:

``const myMap = new Map();const keyBigInt = BigInt("12345678901234567890");const value = "Some value";myMap.set(keyBigInt, value);console.log(myMap.get(keyBigInt)); // Output: "Some value"``

You can use BigInt as a value in a `Set`:

``const mySet = new Set();const valueBigInt = BigInt("12345678901234567890");mySet.add(valueBigInt);console.log(mySet.has(valueBigInt)); // Output: true``

### What happens when you mix regular numbers with BigInts?​

Interview Response: We should never mix BigInts and regular numbers in mathematical operations because they result in errors without conversion. If needed, we should explicitly convert them using BigInt() or Number(). They must be the same type for such operations.

Code Example:

``console.log(1n + 2); // Error: Cannot mix BigInt and other types// Explicit Conversionlet bigint = 1n;let number = 2;// number to bigintconsole.log(bigint + BigInt(number)); // 3// bigint to numberconsole.log(Number(bigint) + number); // 3``

### Is it possible to use the unary operator on BigInts?​

Interview Response: Yes, you can use the unary '-' operator to negate BigInts in JavaScript. However, the unary '+' operator cannot be used with BigInts; it will cause a TypeError.

Code Example:

``let bigIntVal = BigInt(10);console.log(-bigIntVal); // Outputs: -10n``

In this example, the unary '-' operator is used to negate a BigInt.

However, using the '+' operator will result in a TypeError:

``let bigIntVal = BigInt(10);console.log(+bigIntVal); // TypeError: Cannot convert a BigInt value to a number``

### Although comparisons work with BigInt, what should you always remember?​

Interview Response: When comparing BigInt values, you should always remember to use the appropriate comparison operators (===, !==, <, <=, >, >=), and not the identity operator (== or !=), which may perform a type coercion and produce unexpected results.

Code Example:

``console.log(1 == 1n); // trueconsole.log(1 === 1n); // false``

### Can you compare BigInt and Number using comparison operators?​

Interview Response: Yes, BigInt and Number can be compared directly using comparison operators, such as '>', '<', '>=', and '<='.

Code Example:

``let bigint = 1234567890123456789012345678901234567890n;let number = 1234567890;console.log(bigint > number);  // Outputs: trueconsole.log(bigint < number);  // Outputs: falseconsole.log(bigint === number);  // Outputs: false``

### How does JavaScript handle equality checks between BigInt and Number?​

Interview Response: JavaScript treats BigInt and Number as different types. Therefore, even if their values are the same, '===' equality check will return false.

Interview Response: In JavaScript, BigInt and Number are considered to be two different types, so using the strict equality operator === to compare a BigInt and a Number will always return false, even if they are numerically equal. This is because === checks not only the value, but also the type of its operands.

Code Example:

For example...

``let bigint = 123n;let number = 123;console.log(bigint === number); // Outputs: false``

However, if you use the loose equality operator `==`, JavaScript will perform type coercion if the types of the operands are different. In the case of comparing a BigInt and a Number, this means the Number will be converted to a BigInt, and then the comparison will be done. So, a BigInt and a Number that are numerically equal will be considered equal by the `==` operator.

For example:

``let bigint = 123n;let number = 123;console.log(bigint == number); // Outputs: true``

note

It's important to note that using `==` can sometimes lead to unexpected results due to type coercion, so many developers prefer to always use `===` and handle type conversion explicitly when necessary.

### Can you use BigInt with JSON.stringify?​

Interview Response: No, the JSON object does not support the BigInt data type, and calling JSON.stringify on an object with BigInt values will throw an error.

Code Example:

``let data = {  id: 9007199254740993n};console.log(JSON.stringify(data)); // Throws TypeError: Do not know how to serialize a BigInt``

There are ways to work around this, though, such as by defining a `toJSON` method on the object that converts BigInt values to strings or numbers. Here's an example of converting BigInt values to strings:

``let data = {  id: 9007199254740993n,  toJSON() {    return {      id: this.id.toString()    };  }};console.log(JSON.stringify(data)); // Outputs: {"id":"9007199254740993"}``

note

But please note that when you deserialize the JSON string, you'll have to convert the string back to a BigInt if needed. Also, remember that Number can only safely represent integers up to `Number.MAX_SAFE_INTEGER` (`9007199254740991`), so converting a BigInt to a Number can result in loss of precision if the BigInt is larger than that.