A number value is made up of any series of numeric characters, for example:
5
The number data type also includes a few special global properties that
represent numeric concepts, such as Infinity
and NaN
—a value meaning
"not a number," a potential result of attempting to perform mathematical
calculations on nonnumber values.
The number object
When a value is passed to the Number()
function, that value is converted to
the number equivalent. For example, a numeric string results in an equivalent
number primitive:
Number( "10" );
> 10
Passing a false
or null
value to Number()
returns 0
, and true
returns
1
.
Number( null );
> 0
Number( false );
> 0
Number( true );
> 1`
If a value can't be converted, as in the case of undefined
or a string
containing nonnumeric characters, the Number
function returns NaN
:
Number( undefined );
> NaN
Number( "The number 3." );
> NaN
As detailed in prototypal inheritance,
you'll likely have little to no reason to use the Number
object as a
constructor, because it creates a Number
object instead of a number literal.
let numObject = new Number( 15 );
numObject;
> Number { 15 }
This object behaves as its assigned value for mathematical operations, but it fails strict equality comparisons against number literals because the data types don't match, without providing any practical benefit over a literal value.
let tenObject = new Number( 10 );
tenObject + 5;
> 15
tenObject === 10;
> false
Floats and integers
JavaScript only has one number type: 64bit IEEE 7541985 double precision
floatingpoint numbers between
2^1024
and 2^1024
. Before JavaScript stores any number in memory, it first
converts that number to a binary floatingpoint number, also called a float.
This 64bit storage (one positive or negative "sign" bit, 11 bits for an exponent, and 52 bits for a fraction) can cause precision errors with any number of digits that don't fit within an allowable range. This limitation is inherent to JavaScript's number data type.
0.1 + 0.7
> 0.7999999999999999
A number value can instead be stored as an "integer," a floatingpoint number
without a fraction between (2^53 − 1)
and 2^53 − 1
. Because floats and
integers are stored in the same fundamental way, there's no practical difference
in how these numbers operate. However, we recommend using whole numbers whenever
possible to avoid precision errors.
Number operators
When you use standard mathematical operators with number primitives, the mathematical order of operations applies: any expressions wrapped in parentheses are evaluated first, followed by exponents, multiplication, division, addition, and subtraction.
Operator  Name  Description  Usage  Result 

+ 
Addition  2+2 
4 

 
Subtraction  42 
2 

* 
Multiplication  2*5 
10 

/ 
Division  10/5 
2 

++ 
Increment  Adds one to a number  2++ 
3 
 
Decrement  Subtracts one from a number  3 
2 
** 
Exponent  Returns the result of raising the first operand to the power of the second operand. 
2**4 
16 
% 
Remainder  Returns the remainder left over when the first operand is divided by the second operand. 
12%5 
2 
You can also use mathematical assignment operators to perform a mathematical operation on the value of a variable and immediately assign that newlycalculated value to the variable.
Operator  Name  Usage 

+= 
Addition assignment  myValue += 2 
= 
Subtraction assignment  myValue = 2 
*= 
Multiplication assignment  myValue *= 2 
/= 
Division assignment  myValue /= 2 
**= 
Exponent assignment  myValue **= 2 
%= 
Remainder assignment  myValue %= 2 
Symbolic values
The number primitive also applies to a few special cases: the "not a number"
value (NaN
) and a value representing infinity that can be either positive
(Infinity
) or negative (Infinity
).
You might encounter Infinity
rarely as the result of dividing by zero, a case
in which most programming languages throw an error instead:
10 / 0
> Infinity
Remember that JavaScript is casesensitive. Infinity
is a number data type
representing the concept of infinity, but infinity
has no special meaning:
Infinity
> Infinity
infinity
> Uncaught ReferenceError: infinity is not defined
NaN
(meaning "Not a Number")
shows up more frequently, in cases when the result of an arithmetic operation
can't be expressed as a number. For example, because JavaScript tries to infer
data type from value and context, a string literal containing only a number can
be used in a mathematical operation:
"2" * 2;
> 4
However, if that string can't be parsed as a number value, the mathematical operation results in a nonnumber:
"two" * 2;
> NaN
NaN
is returned in any case where an invalid value is represented as a number
in a mathematical operation. Examples include the following:
 Failed number conversions (for example,
parseInt( undefined )
)  Arithmetic operations where the result isn't a real number (for example,
0 / 0
,Math.sqrt( 10 )
)  An arithmetic operation with an indeterminate result (
0 * Infinity
)  An arithmetic operation that includes either an explicit
NaN
(NaN + 2
) or aNaN
result (2 * "string" / 2
)
Check your understanding
What is the result of passing false
to Number()
?
What is the result of the following mathematical operation?
"Six" * 3