Números JavaScript
JavaScript tem apenas um tipo de número. Os números podem ser escritos com ou sem decimais.
Exemplo
let x = 3.14; // A number with decimals
let y = 3; // A number without decimals
Números extra grandes ou extra pequenos podem ser escritos com notação científica (expoente):
Exemplo
let x = 123e5; // 12300000
let y = 123e-5; // 0.00123
Números JavaScript são sempre ponto flutuante de 64 bits
Ao contrário de muitas outras linguagens de programação, JavaScript não define diferentes tipos de números, como 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.
Este formato armazena números em 64 bits, onde o número (a fração) é armazenado nos bits 0 a 51, o expoente nos bits 52 a 62 e o sinal no bit 63:
| Valor (também conhecido como Fração/Mantissa) | Expoente | Sinal |
|---|---|---|
| 52 bits (0 - 51) | 11 bits (52 - 62) | 1 bit (63) |
Precisão de inteiro
Números inteiros (números sem ponto ou notação de expoente) são precisos até 15 dígitos.
Exemplo
let x = 999999999999999; // x will be 999999999999999
let y = 9999999999999999; // y will be 10000000000000000
O número máximo de casas decimais é 17.
Precisão flutuante
A aritmética de ponto flutuante nem sempre é 100% precisa:
let x = 0.2 + 0.1;
Para resolver o problema acima, ajuda a multiplicar e dividir:
let x = (0.2 * 10 + 0.1 * 10) / 10;
Adicionando números e strings
AVISO !!
JavaScript usa o operador + para adição e concatenação.
Os números são adicionados. As strings são concatenadas.
Se você adicionar dois números, o resultado será um número:
Exemplo
let x = 10;
let y = 20;
let z = x + y;
Se você adicionar duas strings, o resultado será uma concatenação de strings:
Exemplo
let x = "10";
let y = "20";
let z = x + y;
Se você adicionar um número e uma string, o resultado será uma concatenação de strings:
Exemplo
let x = 10;
let y = "20";
let z = x + y;
Se você adicionar uma string e um número, o resultado será uma concatenação de strings:
Exemplo
let x = "10";
let y = 20;
let z = x + y;
Um erro comum é esperar que esse resultado seja 30:
Exemplo
let x = 10;
let y = 20;
let z = "The result is: " + x + y;
Um erro comum é esperar que esse resultado seja 102030:
Exemplo
let x = 10;
let y = 20;
let z = "30";
let result = x + y + z;
O interpretador JavaScript funciona da esquerda para a direita.
Primeiro 10 + 20 é adicionado porque x e y são ambos números.
Então 30 + "30" é concatenado porque z é uma string.
Strings Numéricas
As strings JavaScript podem ter conteúdo numérico:
let x = 100; // x is a number
let y = "100"; // y is a
string
O JavaScript tentará converter strings em números em todas as operações numéricas:
Isso funcionará:
let x = "100";
let y = "10";
let z = x / y;
Isso também funcionará:
let x = "100";
let y = "10";
let z = x * y;
E isso vai funcionar:
let x = "100";
let y = "10";
let z = x - y;
Mas isso não vai funcionar:
let x = "100";
let y = "10";
let z = x + y;
No último exemplo JavaScript usa o operador + para concatenar as strings.
NaN - Não é um número
NaNé uma palavra reservada JavaScript que indica que um número não é um número legal.
Tentar fazer aritmética com uma string não numérica resultará em NaN(Not a Number):
Exemplo
let x = 100 / "Apple";
No entanto, se a string contiver um valor numérico , o resultado será um número:
Exemplo
let x = 100 / "10";
Você pode usar a função JavaScript global isNaN()
para descobrir se um valor não é um número:
Exemplo
let x = 100 / "Apple";
isNaN(x);
Cuidado com NaN. Se você usar NaNem uma operação matemática, o resultado também será NaN:
Exemplo
let x = NaN;
let y = 5;
let z = x + y;
Ou o resultado pode ser uma concatenação como NaN5:
Exemplo
let x = NaN;
let y = "5";
let z = x + y;
NaNé um número: typeof NaNretorna number:
Exemplo
typeof NaN;
Infinidade
Infinity(ou -Infinity) é o valor que o JavaScript retornará se você calcular um número fora do maior número possível.
Exemplo
let myNumber = 2;
// Execute until Infinity
while (myNumber != Infinity) {
myNumber = myNumber * myNumber;
}
A divisão por 0 (zero) também gera Infinity:
Exemplo
let x = 2 / 0;
let y = -2 / 0;
Infinityé um número: typeof Infinityretorna number.
Exemplo
typeof Infinity;
Hexadecimal
JavaScript interpreta constantes numéricas como hexadecimais se forem precedidas por 0x.
Exemplo
let x = 0xFF;
Nunca escreva um número com 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 toString()método para gerar números da base 2
para a base 36 .
Hexadecimal é base 16 . Decimal é base 10 . Octal é base 8 . Binário é base 2 .
Exemplo
let myNumber = 32;
myNumber.toString(10);
myNumber.toString(32);
myNumber.toString(16);
myNumber.toString(8);
myNumber.toString(2);
Números JavaScript como objetos
Normalmente, os números JavaScript são valores primitivos criados a partir de literais:
let x = 123;
Mas os números também podem ser definidos como objetos com a palavra-chave new:
let y = new Number(123);
Exemplo
let x = 123;
let y = new Number(123);
Não crie objetos Number.
A newpalavra-chave complica o código e diminui a velocidade de execução.
Objetos numéricos podem produzir resultados inesperados:
Ao usar o ==operador, x e y são iguais :
let x = 500;
let y = new Number(500);
Ao usar o ===operador, x e y não são iguais .
let x = 500;
let y = new Number(500);
Observe a diferença entre (x==y)e (x===y).
(x == y) verdadeiro ou falso?
let x = new Number(500);
let y = new Number(500);
(x === y) verdadeiro ou falso?
let x = new Number(500);
let y = new Number(500);
Comparing two JavaScript objects always returns false.
Complete JavaScript Number Reference
For a complete Number reference, visit our:
Complete JavaScript Number Reference.
The reference contains descriptions and examples of all Number properties and methods.