Números em

Sobre Números

Existem dois tipos diferentes de números em JavaScript: os números e os "bigints".

Os números são os mais utilizados e representam o tipo de dados numérico no formato de vírgula flutuante de precisão dupla de 64 bits.

• number: um tipo de dados numérico no formato de vírgula flutuante de precisão dupla de 64 bits (IEEE 754). Exemplos: -6, -2.4, 0, 0.1, 1, 3.14, 16.984025, 25, 976, 1024.0 e 500000.
• bigint: um tipo de dados numérico que consegue representar inteiros no formato de precisão arbitrária. Exemplos: -12n, 0n, 4n e 9007199254740991n.

let numericValue = 42;
// => 42

Um literal numérico como 42 no código JavaScript é um valor de vírgula flutuante, não um inteiro. Não existe um tipo inteiro separado no uso comum do dia a dia. O tipo bigint não foi concebido para substituir o tipo number nos usos do dia a dia. 42 continua a ser um Number, não um BigInt.

Os números também podem ser expressos em formas literais como 0b101, 0o13, 0x0A. Sabe mais sobre a gramática lexical numérica aqui.

Notações especiais

Notação exponencial

A notação E indica um número que deve ser multiplicado por 10 elevado a uma determinada potência. O formato da notação E consiste em ter um número, seguido de e ou E e depois a potência de 10 pela qual multiplicar.

const num = 3.125e7;
// => 31250000
// The notation essentially says, "Take 3.125 and multiply it by 10^7".

A notação E também pode ser usada para representar números muito pequenos:

const num = 325987e-6; // Equals 0.325987
// The notation essentially says, "Take 325987 and multiply it by 10^-6.

Notação com sublinhados

Os sublinhados podem ser usados para tornar os números grandes mais fáceis de ler para o utilizador. O compilador ignora completamente os sublinhados.

const num = 1_000_000; // You can read this as 1,000,000
console.log(num);
// => 1000000

Objeto incorporado

Existem dois objetos incorporados que são úteis quando trabalhas com números:

• Number: propriedades estáticas para valores comuns ou úteis, métodos estáticos para verificação de tipos e conversão de tipos, métodos de instância para conversão de tipos e formatação de números como strings.
• Math: propriedades e métodos para constantes e funções matemáticas; não funciona com BigInt.

Math também inclui métodos para arredondar números. Podes ler mais sobre as opções de arredondamento disponíveis neste artigo do javascript.info sobre arredondamento.

Math.floor(234.34); // => 234
Math.ceil(234.34); // => 235

O object global incorporado Number é também uma function global que pode ser usada para converter quase tudo que se pareça com um número num number. É menos tolerante do que analisar uma string para a converter num number.

const date = new Date('December 17, 1995 03:24:00');
const unix = Number(date);

unix;
// => 819199440000

Existem três tipos de valores máximos (e mínimos / máximos negativos) para os números em JavaScript:

• VALUE: dado por Number.MAX_VALUE e Number.MIN_VALUE
• INFINITY: dado por Number.POSITIVE_INFINITY e Number.NEGATIVE_INFINITY
• SAFE_INTEGER: dado por Number.MAX_SAFE_INTEGER e Number.MIN_SAFE_INTEGER

Devido à forma como os números em JavaScript são implementados, nem todos os números entre Number.MIN_VALUE e Number.MAX_VALUE podem ser representados. No entanto, todos os números entre Number.MIN_SAFE_INTEGER - 1 e Number.MAX_SAFE_INTEGER + 1 podem ser representados.

Valores numéricos especiais

O JavaScript tem vários valores numéricos especiais:

• Dois valores de erro, NaN e Infinity.
• Dois valores para o zero, +0 e -0.

NaN - Not a Number

O valor de erro NaN (também conhecido como "Not a Number") é produzido nos seguintes casos.

• Não foi possível analisar um número:

  Number('123'); // => 123
  Number('Hello, World!'); // => NaN
  

• Uma operação falhou:

  Math.sqrt(-64); // => NaN
  

• Um dos operandos é NaN:

  NaN + 69; // => NaN
  

NaN é o único valor que não é igual a si próprio:

NaN === NaN; // => false

Se quiseres verificar se um valor é NaN, tens de usar a função global isNaN():

isNaN(NaN); // => true
isNaN(123); // => false

Infinity

Infinity é um valor de erro que indica um de dois problemas:

• Não é possível representar um número porque a sua magnitude é demasiado grande.

  Math.pow(2, 1024); // => Infinity
  

• Ocorreu uma divisão por zero.

  6 / 0; // => Infinity
  -6 / 0; // => -Infinity
  

Infinity é maior do que qualquer outro número (exceto NaN). Da mesma forma, -Infinity é menor do que qualquer outro número (exceto NaN).

A função global isFinite() permite-te verificar se um valor é um número real (nem infinito nem NaN):

isFinite(80085); // => true
isFinite(Infinity); // => false
isFinite(NaN); // => false

Os dois zeros

+0 e -0 são números distintos em JavaScript. Podem ser produzidos se representares um número tão pequeno que seja indistinguível de 0. O zero com sinal permite-te registar "de que direção" te aproximaste do zero, ou seja, que sinal o número tinha antes de ser considerado zero. É boa prática fazer de conta que só existe um zero.

Comparação

Dois números são considerados iguais se tiverem o mesmo valor.

1 == 1.0;
// => true

1 === 1.0;
// => true
// Remember, all numbers are floating-points, so this is
// different syntax for the exact same value.

1 === 1n;
// => false
// Strictly checking a number against a bigint will always result
// in false.

Consulta comparação para mais informações sobre comparações em geral e sobre a comparação de valores numéricos em JavaScript.

Armadilhas

Como os números em JavaScript são números de vírgula flutuante, toda a matemática que usa estes valores é matemática de vírgula flutuante. Por isso, em JavaScript:

0.1 + 0.2 === 0.3;
// => false

Consulta 0.30000000000000004.com para uma breve explicação e o Apêndice D do Numerical Computation Guide da Oracle, "What Every Computer Scientist Should Know About Floating-Point Arithmetic", para uma explicação mais aprofundada.