Maximum and Minimum Values for Integers in JavaScript

Introduction

JavaScript is a remarkably flexible language, but it's not without its limitations. One of these limitations is the maximum and minimum integer value that can be accurately represented. In this Byte, we'll discuss the JavaScript number type, the maximum and minimum integer values in JavaScript, and how you can work around these limitations if needed.

JavaScript's Number Type

In JavaScript, numbers are stored as 64-bit floating point values, following the international IEEE 754 standard. This format stores numbers in three parts: the sign, the exponent, and the fraction. It's this format that allows JavaScript to handle a very wide range of values, from very small to very large.

However, because of the way numbers are stored, there is a limit to the size of an integer that can be accurately represented.

Maximum Integer Value in JavaScript

The largest exact integral value that JavaScript can represent is 2^53 - 1, or 9007199254740991. This value is defined in JavaScript as Number.MAX_SAFE_INTEGER.

console.log(Number.MAX_SAFE_INTEGER);
// Output: 9007199254740991

Note: The term "safe" in MAX_SAFE_INTEGER refers to the ability to represent integers exactly and to correctly compare them. For example, (Number.MAX_SAFE_INTEGER + 1) === Number.MAX_SAFE_INTEGER will return true, because the value of Number.MAX_SAFE_INTEGER + 1 can't be represented exactly and is rounded to Number.MAX_SAFE_INTEGER.

Minimum Integer Value in JavaScript

Similarly, the smallest exact integral value that JavaScript can represent is -(2^53 - 1), or -9007199254740991. This value is defined in JavaScript as Number.MIN_SAFE_INTEGER.

console.log(Number.MIN_SAFE_INTEGER);
// Output: -9007199254740991

Remember that these limitations are inherent to the way JavaScript (and many other languages) represent numbers. If you need to work with larger or smaller integers, you'll need to use a workaround, like the BigInt type, which we'll briefly cover later in this Byte.

Other Number Properties in JavaScript

JavaScript provides a few other built-in properties to work with numbers. For instance, Number.MAX_VALUE returns the largest positive representable number, which is approximately 1.8e+308. On the other hand, Number.MIN_VALUE gives the smallest positive representable number, which is about 5e-324.

console.log(Number.MAX_VALUE);  // 1.7976931348623157e+308
console.log(Number.MIN_VALUE);  // 5e-324

Note: Number.MIN_VALUE is not the lowest number JavaScript can handle. It's the smallest positive number greater than zero that JavaScript can represent with precision.

There's also Number.POSITIVE_INFINITY and Number.NEGATIVE_INFINITY which represent the mathematical concepts of positive and negative infinity.

console.log(Number.POSITIVE_INFINITY);  // Infinity
console.log(Number.NEGATIVE_INFINITY);  // -Infinity

BigInt: An Alternative for Larger Integers

When dealing with numbers larger than Number.MAX_SAFE_INTEGER, JavaScript has another number type called BigInt. It can represent integers of arbitrary length. A BigInt is created by appending n to the end of an integer or by calling the BigInt function.

let big = 9007199254740993n;
console.log(big);  // 9007199254740993n

big = BigInt(9007199254740993);
console.log(big);  // 9007199254740993n

Note: BigInt and Number are not implicitly convertible. You have to manually convert them if you want to use them together in an operation. Keep in mind that you may not be able to accuratley convert a BigInt to a Number due to the fact that it can represent much larger numbers than Number is able to handle.

Conclusion

Understanding JavaScript's number properties, including the maximum and minimum integer values that can be accurately represented, is important for avoiding unexpected results in your calculations. For handling larger integers, BigInt is a great, built-in alternative.