JavaScript is one of the most popular programming languages that is widely used by developers around the world for building dynamic web applications. One of the core features of any programming language is the ability to work with numbers, and JavaScript is no exception. In this article, we will explore the range of numbers in JavaScript, how they are treated in the language, and provide code examples for better understanding.
In JavaScript, numbers are represented internally as 64bit floatingpoint values. These are also known as doubleprecision floats, which means that they have a length of 64 bits with a decimal point. With this representation, JavaScript can handle both integers and floatingpoint values, depending on the context.
Here is an example of how to declare a number in JavaScript:
let num = 42;
In this example, we declare a variable num
and assign it the value 42. This is a simple integer value that JavaScript will represent internally as a doubleprecision float.
There are a few different types of numbers that can be represented in JavaScript:

Integers – whole numbers with no decimal point, such as 42 or 100.

Floatingpoint – numbers with a decimal point, such as 3.14 or 0.001.

Infinity – a special value in JavaScript that represents a value that is too large to be represented as a finite number.

NaN – another special value in JavaScript that represents the result of an operation that cannot be expressed as a valid number. This can occur, for example, when you try to divide by zero.
Now let’s explore the range of numbers in JavaScript.
Integer Range
In JavaScript, the range of integers that can be represented is from 2^53 to 2^53. This is because JavaScript uses 64bit floatingpoint values, which means that there are 53 bits available for the integer portion of the number. The remaining bits are used to represent the decimal portion of the number.
Here is an example of how to create a large integer value in JavaScript:
let largeNum = 9007199254740991; //2^53  1
In this example, we create a variable called largeNum
and assign it the value of 2^53 – 1. This is the largest integer value that can be represented in JavaScript.
FloatingPoint Range
The range of floatingpoint numbers that can be represented in JavaScript is much larger than the range of integers. JavaScript can represent values from approximately 1.7976931348623157 x 10^308 to 1.7976931348623157 x 10^308 with 15 decimal digits of precision.
Here is an example of how to create a large floatingpoint value in JavaScript:
let largeFloat = 1.7976931348623157e308;
In this example, we create a variable called largeFloat
and assign it the value of 1.7976931348623157 x 10^308. This is the largest floatingpoint value that can be represented in JavaScript.
Infinity and NaN
JavaScript has two special values that are used to represent Infinity and NaN. Here is an example of how to create these values in JavaScript:
let infinity = Infinity; //represents a value that is too large to be represented as a finite number
let nan = NaN; //represents the result of an operation that cannot be expressed as a valid number
In these examples, we create variables called infinity
and nan
and assign them the values of Infinity and NaN, respectively.
Working with Numbers in JavaScript
Now that we have a better understanding of the range of numbers that can be represented in JavaScript, let's take a look at some code examples for working with numbers in JavaScript.
let x = 5;
let y = 3;
let z = x + y; //8
In this example, we declare two variables x
and y
, assign them the values 5 and 3 respectively, and then declare a third variable z
and assign it the value of x + y
. This will result in z
being set to 8.
let a = 10;
let b = 2;
let c = a / b; //5
In this example, we declare two variables a
and b
, assign them the values 10 and 2 respectively, and then declare a third variable c
and assign it the value of a / b
. This will result in c
being set to 5.
let d = 0;
let e = 1 / d; //NaN
In this example, we declare a variable d
and assign it the value of 0. We then declare a second variable e
and assign it the value of 1 / d
. This will result in e
being set to NaN, as dividing by zero is not a valid operation.
Conclusion
In this article, we have explored the range of numbers in JavaScript and how they are represented internally in the language. We have covered the different types of numbers that can be represented, including integers, floatingpoint values, Infinity and NaN. We have also provided code examples for working with numbers in JavaScript. By understanding the range of numbers in JavaScript, you will be better equipped to work with numbers in your JavaScript applications.
let's dive a bit deeper into some of the topics covered in the article.
Integer Range
As mentioned in the article, JavaScript can represent integers within a range of 2^53 to 2^53. This is because JavaScript uses 64bit floatingpoint values, which have 53 bits to represent integers. If a number is outside of this range, it will be rounded to the nearest representable number or will be represented as Infinity.
However, it's worth noting that even though JavaScript can represent integers within this range, there are certain mathematical operations that may result in unexpected behavior due to the limitations of the floatingpoint representation. For example:
console.log(9999999999999999 + 1); // 10000000000000000
console.log(9999999999999999 + 2); // 10000000000000000
In this example, adding 1 to 9999999999999999 results in the expected value of 10000000000000000. However, adding 2 instead results in the same value, which is unexpected. This is because the number 9999999999999999 is not exactly representable in binary form within the 64bit floatingpoint representation, causing small rounding errors to occur in certain operations.
To avoid unexpected behavior like this, it's important to be aware of the limitations of the floatingpoint representation and use appropriate techniques like rounding or integeronly arithmetic when working with integer values in JavaScript.
FloatingPoint Range
JavaScript's floatingpoint range is extremely large, allowing for representation of very large and very small numbers with relatively high precision. However, as with any floatingpoint representation, there are certain numbers that cannot be exactly represented within the range.
One example of this is the value 0.1, which cannot be exactly represented in binary. When this value is represented in JavaScript's floatingpoint format, it may be slightly off from the expected value:
console.log(0.1 + 0.2); // 0.30000000000000004
To avoid issues like this, it's important to be aware of the limitations of the floatingpoint representation and use appropriate rounding techniques or libraries like BigNumber.js if highprecision floatingpoint arithmetic is needed.
Working with Numbers in JavaScript
In addition to the code examples provided in the article, there are a few other important things to keep in mind when working with numbers in JavaScript.
One of these is the concept of type coercion, which is when a value of one type is automatically converted to another type in certain situations. For example, if you try to add a string and a number in JavaScript, the number will be coerced into a string:
console.log("hello" + 42); // "hello42"
This can be useful in some cases, but can also lead to unexpected behavior if not understood properly. To avoid issues like this, it's important to be aware of the types of values being used in your code and use appropriate techniques like type checking or explicit type conversion when needed.
Another important thing to keep in mind when working with numbers in JavaScript is the use of the strict equality (===) operator. This operator checks both the value and the type of two values being compared, whereas the normal equality (==) operator can perform type coercion before comparison, potentially leading to unexpected behavior.
Conclusion
JavaScript's range of numbers is expansive, allowing for representation of a wide variety of values with relatively high precision. However, understanding the limitations and potential issues associated with floatingpoint representation and type coercion is important for writing correct and reliable code. By using appropriate techniques and being aware of these issues, you can effectively work with numbers in JavaScript and avoid potential pitfalls.
Popular questions

What is the range of integers that can be represented in JavaScript?
Answer: JavaScript can represent integers within the range of 2^53 to 2^53. 
What is the largest integer value that can be represented in JavaScript?
Answer: The largest integer value that can be represented in JavaScript is 2^53 – 1, which is approximately 9 quadrillion. 
What is NaN in JavaScript?
Answer: NaN stands for "Not a Number" in JavaScript. It is a special value that indicates the result of an operation that cannot be expressed as a valid number, such as dividing by zero. 
What is the difference between the strict equality (===) operator and the normal equality (==) operator in JavaScript?
Answer: The strict equality (===) operator checks both the value and the type of two values being compared, whereas the normal equality (==) operator can perform type coercion before comparison, potentially leading to unexpected behavior. 
Can JavaScript represent the value 0.1 exactly as a floatingpoint number?
Answer: No, JavaScript cannot represent the value 0.1 exactly as a floatingpoint number due to limitations of the binary representation. This can lead to small rounding errors in certain operations.
Tag
NumericRangeGuide