# All you need to know about BigInt in JavaScript

*Last updated: October 7, 2021.*

Until ECMAScript 2020 (ES11), JavaScript consisted of six ‘primitive’ data types:

- Number
- String
- Boolean
- Null
- Undefined
- Symbol

Primitive types are the most basic possible data in JavaScript, i.e. they cannot be reduced to a more basic type.

With ECMAScript 2020, a seventh primitive type was introduced to the language to the language, `BigInt`

.

In this article, we will cover all you need to know about BigInt: Why we need it, how to create it and features of working with it.

Let’s get started!

## Why we need BigInt

It may surprise you, but JavaScript’s `Number`

type isn’t perfect at handling very large numbers with precision.

In fact, by calling `Number.MAX_SAFE_INTEGER`

, we can see the largest integer that it is safe to work with when working with `Number`

data:

alert(Number.MAX_SAFE_INTEGER); // 9007199254740991

This implies that working with numbers in excess of this is ‘unsafe’. What do we mean?

Concretely, we can work with an integer of type `Numbe`

r up until 9007199254740991 with guaranteed precision. But working with numbers greater than this risks losing precision.

For example, if we try to alert the number `99999999999999999`

as a `Number`

type, you can clearly see the problem:

alert(99999999999999999); // 100000000000000000

This makes exact calculations with very large numbers problematic when using the `Number`

type. It can also be a problem if the number is long but needs to be exact, such as an identification or serial number.

`BigInt`

enables us to work with larger numbers without losing any precision.

## Creating a BigInt

`BigInt`

is a built-in JavaScript object that can be called to create a new `BigInt`

integer.

The first way to create a BigInt integer is to call the object directly. For example:

const largeNumber = BigInt("99999999999999999"); console.log(largeNumber); // 99999999999999999n console.log(typeof largeNumber); // bigint

A more convenient method is to simply place `n`

after a number:

const largeNumber = 99999999999999999n; console.log(largeNumber); // 99999999999999999n console.log(typeof largeNumber), // bigint

## BigInt features

`BigInt`

can handle smaller numbers to, just like `Number`

.

const x = BigInt("2"); console.log(x); // 2n

To distinguish `BigInt`

from `Number`

, `n`

is returned after the interger.

`BigInt`

and `Number`

types cannot be mixed in a calculation. If you try to do so, JavaScript will return an error:

const x = BigInt("2"); const y = 2 console.log(x + y); // Uncaught TypeError: Cannot mix BigInt and other types, use explicit conversions

If we want to make such a calculation, we can by convert the `Number`

to a `BigInt`

by passing it inside `BigInt()`

:

const x = BigInt("2"); const y = 2; console.log(x + BigInt(y)); // 4n

Or, by converting the `BigInt`

value to a `Number`

type by passing it through `Number()`

:

const x = BigInt("2"); const y = 2; console.log(Number(x) + y); // 4

When making comparisons, if BigInt and Number contain the same value, they are considered equal (`==`

) but not strictly equal (`===`

):

const x = BigInt("2"); const y = 2; alert(x==y); // true alert(x===y); // false

## Summary

In this article, we have seen why we need BigInt, how to create one and its most important features.

It is not a primitive data type that you will use anywhere near as much as Number, String or Boolean. However, it is a welcome addition that increases the reliability of the language.