Este objeto indica el tipo de número de datos en el que JS trabaja. Podemos asignar un número a una variable o darle un valor a través del constructor Número, de la siguiente manera:

a = new Number (value) ;, por ejemplo, a = new Number (3.2); está haciendo el valor 3.2 Si no pasamos el valor constructor, la variable se inicializará con 0.

propiedades de los números

JavaScript Numbers

Ejemplo

var pi=3.14; // Número con decimales

var x=34; // Número sin decimales

Ejemplo

var x = 123e5; // 12300000

var y = 123e-5; // 0.00123

JavaScript Numbers are 64-bit Floating Point

JavaScript is not a typed language. Unlike many other programming languages, it does not define different types of numbers, like integers, short, long, floating-point etc.

JavaScript numbers are always stored as double precision floating point numbers, following the international IEEE 754 standard.

This format stores numbers in 64 bits, where the number (the fraction) is stored in bits 0 to 51, the exponent in bits 52 to 62, and the sign in bit 63:

Precision

Integers (numbers without a period or exponent notation) are considered accurate up to 15 digits.

The maximum number of decimals is 17, but floating point arithmetic is not always 100% accurate:

Example

var x = 0.2+0.1; // result will be 0.30000000000000004

Octal y hexadecimal

JavaScript interprets numeric constants as octal if they are preceded by a zero, and as hexadecimal if they are preceded by a zero and "x".

Example

var y = 0377; // Codigo octal

var z = 0xFF; // Codigo hexadecimal

By default, Javascript displays numbers as base 10 decimals.

But you can use the toString() method to output numbers as base 16 (hex), base 8 (octal), or base 2 (binary).

Example

var myNumber=128;

myNumber.toString(16); // returns 80

myNumber.toString(8); // returns 200

myNumber.toString(2); // returns 10000000

Infinity

If you calculate a number outside the largest number provided by Javascript, Javascript will return the value of Infinity or -Infinity (positive or negative overflow):

Example

myNumber=2;

while (myNumber!=Infinity)

{

myNumber=myNumber*myNumber; // Calculate until Infinity

}

Division by 0 (zero) also generates Infinity:

Example

var x = 2/0;

var y = -2/0;

Try it yourself »

NaN - Not a Number

NaN is JavaScript reserved word indicating that the result of a numeric operation was not a number.

You can use the global JavaScript function isNaN(value) to find out if a value is a number.

Example

var x = 1000 / "Apple";

isNaN(x); // returns true

var y = 100 / "1000";

isNaN(y); // returns false

Division by 0 (zero) generates Infinity, but Infinity is a number:

Adibidea

var x = 1000 / 0;

isNaN(x); // returns false

Numbers Can be Numbers or Objects

JavaScript numbers can be primitive values created from literals, like var x = 123;

JavaScript number can also be objects created with the new keyword, like var y = new Number(123);

Example

var x = 123;

var y = new Number(123);

typeof(x) // returns Number

typeof(y) // returns Object

Try it yourself »

Normally, because of some nasty side effects, you will not define numbers as objects.

Example

var x = 123;

var y = new Number(123);

(x === y) // is false because x is a number and y is an object.

Try it yourself »

Number Properties

• MAX_VALUE
• MIN_VALUE
• NEGATIVE_INFINITY
• POSITIVE_INFINITY
• NaN
• prototype
• constructor

All number properties are properties of JavaScripts' number object wrapper called Number.

These properties can only be accessed as Number.MAX_VALUE.

Using num.MAX_VALUE, where num is a created object or a primitive number value, will return undefined.

Number Methods

• toExponential()
• toFixed()
• toPrecision()
• toString()
• valueOf()

Note: Primitive values, like 3.14, cannot have properties and methods (because they are not objects).

With JavaScript, all methods of the number object are also available to primitive values, because Javascript will temporarily transfer primitive values to objects before executing the methods.

Complete Number Object Reference

For a complete reference of all the properties and methods that can be used with the Number object, go to our Complete Number Object Reference.

The reference contains both descriptions and examples, for each property and method.

JavaScript Number Methods

Number methods help you to work with numbers.

Global Methods

JavaScript global functions can be used on all JavaScript data types.

These are the most relevant methods, when working with numbers:

Number Methods

JavaScript number methods are methods that can be used on numbers:

The toString() Method

toString() returns a number as a string.

All number methods can be used on any type of numbers (literals, variables, or expressions):

Example

var x = 123;

x.toString(); // returns 123 from variable x

(123).toString(); // returns 123 from literal 123

(100 + 23).toString(); // returns 123 from expression 100 + 23

Try it yourself »

The toExponential() Method

toExponential() returns a string, with a number rounded and written using exponential notation.

A parameter defines the number of character behind the decimal point:

Example

var x = 9.656;

x.toExponential(2); // returns 9.66e+0

x.toExponential(4); // returns 9.6560e+0

x.toExponential(6); // returns 9.656000e+0

Try it yourself »

The parameter is optional. If you don't specify it, JavaScript will not round the number.

The toFixed() Method

toFixed() returns a string, with the number written with a specified number of decimals:

Example

var x = 9.656;

x.toFixed(0); // returns 10

x.toFixed(2); // returns 9.66

x.toFixed(4); // returns 9.6560

x.toFixed(6); // returns 9.656000

Try it yourself »

The toPrecision() Method

toPrecision() returns a string, with a number written with a specified length:

Example

var x = 9.656;

x.toPrecision(); // returns 9.656

x.toPrecision(2); // returns 9.7

x.toPrecision(4); // returns 9.656

x.toPrecision(6); // returns 9.65600

Try it yourself »

Converting Variables to Numbers

There are 3 JavaScript functions that can be used to convert variables to numbers:

• The Number() method
• The parseInt() method
• The parseFloat() method

These methods are not number methods, but global JavaScript methods.

The Number() Method

Number(), can be used to convert JavaScript variables to numbers:

Example

x = true;

Number(x); // returns 1

x = false;

Number(x); // returns 0

x = new Date();

Number(x); // returns 1404568027739

x = "10"

Number(x); // returns 10

x = "10 20"

Number(x); // returns NaN

Try it yourself »

The parseInt() Method

parseInt() parses a string and returns a whole number. Spaces are allowed. Only the first number is returned:

Example

parseInt("10"); // returns 10

parseInt("10.33"); // returns 10

parseInt("10 20 30"); // returns 10

parseInt("10 years"); // returns 10

parseInt("years 10"); // returns NaN

Try it yourself »

If the number cannot be converted, NaN (Not a Number) is returned.

The parseFloat() Method

parseFloat() parses a string and returns a number. Spaces are allowed. Only the first number is returned:

Example

parseFloat("10"); // returns 10

parseFloat("10.33"); // returns 10.33

parseFloat("10 20 30"); // returns 10

parseFloat("10 years"); // returns 10

parseFloat("years 10"); // returns NaN

Try it yourself »

If the number cannot be converted, NaN (Not a Number) is returned.

The valueOf() Method

valueOf() returns a number as a number.

Example

var x = 123;

x.valueOf(); // returns 123 from variable x

(123).valueOf(); // returns 123 from literal 123

(100 + 23).valueOf(); // returns 123 from expression 100 + 23

Try it yourself »

In JavaScript, a number can be a primitive value (typeof = number) or an object (typeof = object).

The valueOf() method is used internally in JavaScript to convert Number objects to primitive values.

There is no reason to use it in your code.

Complete JavaScript Number Reference

For a complete reference, go to our Complete JavaScript Number Reference.

The reference contains descriptions and examples of all Number properties and methods.