JavaScript has two number types: `Number`

and `BigInt`

.

The most frequently-used number type, `Number`

, is a 64-bit floating point IEEE 754 number.

The largest exact integral value of this type is `Number.MAX_SAFE_INTEGER`

, which is:

- 2
^{53}-1, or - +/- 9,007,199,254,740,991, or
- nine quadrillion seven trillion one hundred ninety-nine billion two hundred fifty-four million seven hundred forty thousand nine hundred ninety-one

To put this in perspective: one quadrillion bytes is a petabyte (or one thousand terabytes).

“Safe” in this context refers to the ability to represent integers exactly and to correctly compare them.

Note that all the positive and negative integers whose magnitude is no

greater than 2^{53}are representable in the`Number`

type (indeed, the

integer 0 has two representations, +0 and -0).

To safely use integers larger than this, you need to use `BigInt`

, which has no upper bound.

Note that the bitwise operators and shift operators operate on 32-bit integers, so in that case, the max safe integer is 2^{31}-1, or 2,147,483,647.

```
const log = console.log
var x = 9007199254740992
var y = -x
log(x == x + 1) // true !
log(y == y - 1) // also true !
// Arithmetic operators work, but bitwise/shifts only operate on int32:
log(x / 2) // 4503599627370496
log(x >> 1) // 0
log(x | 1) // 1
```

Technical note on the subject of the number 9,007,199,254,740,992: There is an exact IEEE-754 representation of this value, and you can assign and read this value from a variable, so for *very carefully* chosen applications in the domain of integers less than or equal to this value, you could treat this as a maximum value.

In the general case, you must treat this IEEE-754 value as inexact, because it is ambiguous whether it is encoding the logical value 9,007,199,254,740,992 or 9,007,199,254,740,993.