A number value is made up of any series of numeric characters, for example:


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 non-number 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 non-numeric 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 );

> 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: 64-bit IEEE 754-1985 double precision floating-point numbers between -2^1024 and 2^1024. Before JavaScript stores any number in memory, it first converts that number to a binary floating-point number, also called a float.

This 64-bit 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 floating-point 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 4-2 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 newly-calculated 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 case-sensitive. Infinity is a number data type representing the concept of infinity, but infinity has no special meaning:

> 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 non-number:

"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 a NaN 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