JavaScript tem apenas um tipo de objeto numérico. Os números podem ser escritos com ou sem decimais.

var x = 3.14;   // Número com decimais
var y = 3;      // Número sem decimais

Números extra grandes ou extra pequenos podem usar notação científica (expoente):

var x = 123e5;    // x === 12300000
var y = 123e-5;   // x === 0.00123

Ponto Flutuante de 64 bits

Ao contrário de muitas outras linguagens de programação, o JavaScript não define diferentes tipos de números, como números inteiros, curtos, longos, de ponto flutuante etc.

Os números JavaScript são sempre armazenados como números de ponto flutuante de precisão dupla, seguindo o padrão internacional IEEE 754.

Esse formato armazena números em 64 bits, onde o valor numérico (a fração) é armazenado nos bits 0 a 51, o expoente nos bits 52 a 62 e o bit no sinal 63:

Valor (Fração/Mantissa)	Expoente	Placa
52 bits (0 - 51)	11 bits (52 - 62)	1 bit (63)

Precisão

Inteiros (números sem ponto ou notação de expoente) têm precisão de até 15 dígitos.

var x = 999999999999999;   // x === 999999999999999
var y = 9999999999999999;  // y === 10000000000000000

O número máximo de casas decimais é 17, mas a aritmética de ponto flutuante nem sempre é 100% precisa:

var x = 0.2 + 0.1;   // x === 0.30000000000000004

Para resolver o problema acima, ajuda a multiplicar e dividir:

var x = (0.2 * 10 + 0.1 * 10) / 10;   // === 0.3

Adicionando Números e Textos

O JavaScript usa o operador + para adição e concatenação.

Números são somados.

Cordas são concatenadas.

Se você adicionar dois números, o resultado será um número:

var x = 10; var y = 20; var z = x + y;   // z === 30 (um númmero)

Se você adicionar duas strings, o resultado será uma concatenação de strings:

var x = "10"; var y = "20"; var z = x + y;   // z === 1020 (uma string)

Se você adicionar um número e uma string, o resultado será uma concatenação de string:

var x = 10; var y = "20"; var z = x + y;   // z === 1020 (uma string)

Se você adicionar uma string e um número, o resultado será uma concatenação de string:

var x = "10"; var y = 20; var z = x + y;    // z === 1020 (a string)

Um erro comum é esperar que esse resultado seja 30:

var x = 10; var y = 20; var z = "Resultado: " + x + y; // z === "Resultado: 1020"

Um erro comum é esperar que esse resultado seja 102030:

var x = 10; var y = 20; var z = "30"; var r = x + y + z;   // r === "3030";

O intérprete JavaScript funciona da esquerda para a direita.

Os primeiros 10 + 20 são adicionados porque x e y são ambos números.

Então 30 + "30" é concatenado porque z é uma string.

Textos Numéricos

As strings JavaScript podem ter conteúdo numérico:

var x = 100;         // x is a number
var y = "100";       // y is a string

O JavaScript tentará converter cadeias de caracteres em números em todas as operações numéricas:

Isso funcionará:

var x = "100"; var y = "10"; var z = x / y;   // z === 10

Isso também funcionará:

var x = "100"; var y = "10"; var z = x * y;   // z === 1000

E isso vai funcionar:

var x = "100"; var y = "10"; var z = x - y;   // z === 90

Mas isso não vai funcionar:

var x = "100"; var y = "10"; var z = x + y; // z === "10010"

No último exemplo, o JavaScript usa o operador + para concatenar as strings.

NaN - Não é um Número

NaN é uma palavra reservada em JavaScript, indicando que um número não é um número legal.

Tentar fazer aritmética com uma sequência não numérica resultará em NaN(Não é um número):

var x = 100 / "Maçã";  // x === NaN (Not a Number)

No entanto, se a sequência contiver um valor numérico, o resultado será um número:

var x = 100 / "10";     // x === 10

Você pode usar a função JavaScript global isNaN()para descobrir se um valor é um número:

var x = 100 / "Maçã"; var y = isNaN(x);   // y === true porque x não é um número

Cuidado com NaN. Se você usar NaNem uma operação matemática, o resultado também será NaN:

var x = NaN; var y = 5; var z = x + y;   // z === NaN

Ou o resultado pode ser uma concatenação:

var x = NaN; var y = "5"; var z = x + y;   // z === NaN

NaN é um número: typeof NaN retorna "number":

var x = typeof NaN;   // x === "number"

Infinidade

Infinity (ou -Infinity) é o valor que o JavaScript retornará se você calcular um número fora do maior número possível.

var myNumber = 2;
while (myNumber != Infinity) {   // Executar até infinidade
  myNumber = myNumber * myNumber;
}

A divisão por 0 (zero) também gera Infinity:

var x =  2 / 0;  // x será Infinity
var y = -2 / 0;  // y será -Infinity

Infinity é um número: typeof Infinity retorna number.

var x = typeof Infinity;   // x === "number"

Hexadecimal

JavaScript interpreta constantes numéricas como hexadecimais se forem precedidas por 0x.

var x = 0xFF;        // x will be 255

Nunca escreva um número com um zero à esquerda (como 07).

Algumas versões do JavaScript interpretam os números como octais se forem escritos com um zero à esquerda.

Por padrão, o JavaScript exibe números como decimais de base 10.

Mas você pode usar o método toString() para gerar números da base 2 para a base 36.

Hexadecimal é a base 16. O decimal é a base 10. Octal é a base 8. Binário é a base 2.

var myNumber = 32;
myNumber.toString(10);  // retorna 32
myNumber.toString(32);  // retorna 10
myNumber.toString(16);  // retorna 20
myNumber.toString(8);   // retorna 40
myNumber.toString(2);   // retorna 100000

Os Números Podem Ser Objetos

Normalmente, os números JavaScript são valores primitivos criados a partir de literais:

var x = 123;

Mas os números também podem ser definidos como objetos com a palavra-chave new:

var y = new Number(123);

Os tipos são diferentes:

var m = typeof x // m === "number'
var n = typeof y // n === "object"

Não crie objetos Number. Diminui a velocidade de execução.

A palavra-chave new complica o código. Isso pode produzir alguns resultados inesperados.

Ao usar o operador ==, números iguais são iguais.

var x = 500;            
var y = new Number(500);
var z = (x == y); // z === true porque x e y têm iguais valores

Ao usar o === operador, números iguais não são iguais, porque o === operador espera igualdade no tipo e no valor.

var x = 500;            
var y = new Number(500);
var z = (x === y) // z === false porque x e y têm diferentes tipos

Ou pior ainda. Objetos não podem ser comparados:

var x = new Number(500);
var y = new Number(500); 
var z = (x == y) // z === false porque objetos não podem ser comparados

Observe a diferença entre (x==y) e (x===y).

A comparação de dois objetos JavaScript sempre retornará false.

Número