Dark Mode On/Off

# Javascript BigInt

As we know, JavaScript has only one data type for numbers which is a Number type. This data type represents a 64-bit floating-point number. It also represents the integers smaller than 2^53. To represent the numbers larger than 2^53-1, BigInt was introduced.

BigInt is a built-in object representing the whole number larger than 2^53-1, which is the largest value that JavaScript can represent. There is no limit specified as to how long a BigInt number can be and in behaviour, BigInt values are pretty similar to number values, but there is a slight difference between them. We can not use a BigInt value with a built-in Math object.

## How to create BigInt?

Well, we can use the `BigInt()` method to create a BigInt type object, The syntax of `BigInt()` is given below:

``BigInt()``

### Example:

``````<!DOCTYPE html>
<html>
<title>BigInt</title>
<body>
<script>
const bigNum = BigInt(9007199254740991)
console.log(bigNum);
const hugeStr = BigInt("9007199254740991")
console.log(hugeStr);
const hexNum = BigInt("0x1fffffffffffff")
console.log(hugehex);
const octalNum = BigInt("0o377777777777777777")
console.log(octalNum);
const binaryNum = BigInt("0b11111111111111111111111111111111111111111111111111111")
console.log(binaryNum);
</script>
</body>
</html>``````

### Output: ## Using Operators with BigInt

BigInt type supports all JS operators especially these `+`, `*`, `-`, `%`, `**`. BigInt also supports the bitwise operator except for the `>>>` and unary `+` operator. The divide operator (`/`) will also work with the whole number,s but the result will not be any fractional digit.

### Example:

In this example, we have divided the two whole numbers using the division operator (`/`) which returns the rounded value 2 instead of 2.5. This is because all the operations performed on BigInt return BigInt.

``````<!DOCTYPE html>
<html>
<title>BigInt</title>
<body>
<script>
const wholeNum = 5n / 2n
console.log(wholeNum);
</script>
</body>
</html>``````

### Output: ## Comparison of BigInt

A BigInt is not strictly equal to a number, but it can be loosely equal. This means when we compare two BigInt values using strictly equal to (`===`), it results in false, but when we compare the same values using loosely equal to (`==`), it will display the result to true.

Let's understand it better using examples.

### Example:

``````<!DOCTYPE html>
<html>
<title>BigInt</title>
<body>
<script>
console.log(2n === 2);
console.log(2n == 2);
</script>
</body>
</html>``````

### Output:

As we can see, the output of the first expression is false, and the second expression is true. ## Conditionals in BigInt

A BigInt value behaves like a number value in the following cases:

• When the BigInt value is converted to a boolean value using the `boolean()` function

• When used with the logical operators such as `||`, `&&`, and `!`.

• Within a conditional test such as `if()` statement.

### Example

``````<!DOCTYPE html>
<html>
<title>BigInt</title>
<body>
<script>
let count = 0n;

if(count) {
console.log("Hello");
}
else {
console.log("Bye");
}
</script>
</body>
</html>``````

### Output:

In the example above, the BigInt value acts as a number and its value is treated as 0, hence, the else block is executed, because 0 value translates to false in if-else statement. ## BigInt with `typeof` operator

The type of a BigInt is BigInt. So when we use the `typeof` operator with the BigInt to know the data type of BigInt, it will return the BigInt type.

### Example:

Here is a simple code example,

``````<!DOCTYPE html>
<html>
<title>BigInt</title>
<body>
<script>
console.log(typeof BigInt(100) === 'bigint');
console.log(typeof 1n === 'bigint')
</script>
</body>
</html>``````

### Output: ## Conclusion

The `BigInt()` method was introduced in ECMAScript 2020 or ES11. This method is used to represent the whole numbers bigger than 2^53 - 1. This method is used to create values which are used to perform complex mathematical calculations.