Como funciona os números no javaScript

Chegamos na parte do roadmap que fala como funciona os números no JavaScript. Em JavaScript tipo number representar valores inteiros e de ponto flutuante. Tecnicamente, o number tipo JavaScript usa o formato IEEE-754.

O ES2020 introduziu um novo tipo primitivo bigint presentando números inteiros grandes com valores maiores que 2 53  – 1. Para oferecer suporte a vários tipos de números, o JavaScript usa diferentes formatos de literais numéricos

Números inteiros

Veja a seguir como declarar uma variável que contém um inteiro decimal:

let counter = 100;

Os inteiros podem ser representados nos seguintes formatos:

• Octal (base 8)
• Hexadecimal (baseado em 16)

Quando você usa os números octais e hexadecimais em operações aritméticas, o JavaScript os trata como números decimais.

Veja também:

Estrutura Básica Do HTML
Introdução rápida sobre CSS
Introdução rápida sobre Python

Números octais

Um número literal octal começa com o dígito zero (0) seguido por uma sequência de dígitos octais (números de 0 a 7). Por exemplo:

let num = 071;
console.log(num);
>>> 57

Se um número octal contiver um número que não esteja no intervalo de 0 a 7, o mecanismo JavaScript ignorará o 0 e tratará o número como um decimal. Por exemplo:

let num = 080;
console.log(num);
>>> 80

Esse comportamento implícito pode causar problemas. Portanto, o ES6 introduziu um novo literal octal que começa com o “0o” seguido por uma sequência de dígitos octais (de 0 a 7). Por exemplo:

let num = 0o71;
console.log(num);
>>> 57

Se você tiver um número inválido após 0o, o JavaScript emitirá um erro de sintaxe como este:

let num = 080;
console.log(num);

Números hexadecimais

Os números hexadecimais começam com 0x ou 0X seguidos por qualquer número de dígitos hexadecimais (0 a 9 e a a f). Por exemplo:

let num = 0x1a;
console.log(num);
>>> 26

Números de ponto flutuante

Para definir um número literal de ponto flutuante, inclua um ponto decimal e pelo menos um número depois disso. Por exemplo:

let price = 9.99;
let tax = 0.08;
let discount = .05; // válido, mas não recomendado

Quando você tem um número muito grande, você pode usar a notação eletrônica. A notação E indica que um número deve ser multiplicado por 10 elevado a uma determinada potência. Por exemplo:

let amount = 3.14e7;
console.log(amount);
>>>31400000

A notação 3.14e7significa que pegue 3.14e multiplique por .107

Da mesma forma, você pode usar a notação E para representar um número muito pequeno. Por exemplo:

let amount = 5e-7;
console.log(amount);
>>>0.0000005

A notação 5e-7 significa que pegue 5 e divida por 10.000.000.

Além disso, o JavaScript converte automaticamente qualquer número de ponto flutuante com pelo menos seis zeros após o ponto decimal em e-notação. Por exemplo:

let amount = 0.0000005;
console.log(amount);
>>> 5e-7

Números de ponto flutuante são precisos até 17 casas decimais. Quando você executa operações aritméticas em números de ponto flutuante, geralmente obtém o resultado aproximado. Por exemplo:

let amount = 0.2 + 0.1;
console.log(amount);
>>> 0.3000000000000000004

Inteiros Grandes

O JavaScript introduziu o bigint tipo a partir do ES2022. O bigint tipo armazena números inteiros cujos valores são maiores que 2⁵³ – 1.

Um literal de inteiro grande tem o n caractere no final de um literal de inteiro como este:

let pageView = 9007199254740991n;

Separador numérico

O separador numérico permite criar uma separação visual entre grupos de dígitos usando sublinhados (_) como separadores.

Por exemplo, o seguinte número é muito difícil de ler, especialmente quando contém longas repetições de dígitos:

const budget = 1000000000;

Isso é um bilhão ou cem milhões?

O separador numérico corrige esse problema de legibilidade da seguinte maneira:

const budget = 1_000_000_000;

Como você pode ver, o número agora é muito fácil de interpretar.

O JavaScript permite que você use separadores numéricos para números inteiros e de ponto flutuante. Por exemplo:

let amount = 120_201_123.05; // 120201123.05
let expense = 123_450; // 123450
let fee = 12345_00; // 1234500

OBS: É importante observar que todos os números em JavaScript são números de ponto flutuante.

Além disso, você pode usar os separadores numéricos para partes fracionais e exponenciais. Por exemplo:

let amount = 0.000_001; // 1 millionth

É importante observar que você pode usar o separador numérico para bigint literal, literal binário, literal octal e literal hexadecimal. Por exemplo:

// BigInt
const max = 9_789_456_123_012_159_753n;

// binary
let nibbles = 0b1011_0101_0101;

// octal
let val = 0o1234_4567;

// hex
let message = 0xD0_E0_f0;

Literais octais e binários

Pois bem, nesse parte vamos falar um pouco mais sobre números octais e binário no JavaScript.

O ES5 fornecia literais numéricos em octal (prefixo 0), decimal (sem prefixo) e hexadecimal (0x). O ES6 adicionou suporte para literais binários e mudou a forma como representa os literais octais.

Literais octais

Para representar um literal octal no ES5, você usa o prefixo zero (0) seguido por uma sequência de dígitos octais (de 0 a 7). Por exemplo:

let a = 051;
console.log(a);
>>> 41

Se o literal octal contiver um número fora do intervalo, o JavaScript ignorará o 0 inicial e tratará o literal octal como um decimal, conforme mostrado no exemplo a seguir:

let b = 058; // invalido octal
console.log(b);
>>> 58

Neste exemplo, como 8 é um dígito inválido para representar o número octal, o JavaScript ignora o 0 e trata o número inteiro como um decimal com valor 58.

Observe que você pode usar os literais octais no modo não estrito. Se você os usar no modo estrito, o JavaScript gerará um erro.

"use strict"
let b = 058; // invalido octal
console.log(b);
>>> SyntaxError: Decimals with leading zeros are not allowed in strict mode.

ES6 permite que você especifique o literal octal usando o prefixo 0o seguido por uma

let b = 0o51;
console.log(b);
>>> 41

Se você usar um número inválido no literal octal, o JavaScript lançará um SyntaxError conforme mostrado no exemplo a seguir:

let b = 0o58;
console.log(b);
>>> SyntaxError 

Literais binários

No ES5, o JavaScript não fornecia nenhuma forma literal para números binários. Para analisar uma string binária, você usa a parseInt() função da seguinte forma:

let e = parseInt('111', 2);
console.log(e);
>>> 7

O ES6 adicionou suporte para literais binários usando o 0b prefixo seguido por uma sequência de números binários (0 e 1). Aqui está um exemplo:

let f = 0b111;
console.log(f);
>>> 7

Veja o primeiro artigo do Roadmap: Introdução rápida sobre JavaScript

Conclusão

Você aprendeu como os número funciona em JavaScript com esse conhecimento você pode construir pequenos projetos que usar número. Antes de passar para o próximo artigo deixa esse assunto bem fixado na sua cabeça. Assim não tenha pressa porque o objetivo não é terminar rápido e sim compreender o assunto.

Então é isso, espero te ajudado. Bons estudos e vamos para próximo artigo.

Perguntas frequentes