Tipos de Dados - JavaScript

Todos os dados usados em JavaScript têm um tipo específico. Existem oito tipos de dados em JavaScript:

String: representa uma sequência de caracteres
Number: representa um valor numérico
BigInt: destinado à representação de números inteiros muito grandes
Boolean: representa um valor lógico verdadeiro ou falso
Undefined: representa um valor especial - undefined, indicando que o valor não foi definido
Null: representa um valor especial - null, indicando a ausência de valor
Symbol: representa um valor único, frequentemente usado para acessar propriedades de objetos complexos
Object: representa um objeto complexo

Os primeiros sete tipos são tipos de dados primitivos. O último tipo - Object - representa um tipo de dado complexo, composto por valores de tipos primitivos ou outros objetos. Vamos considerar os principais tipos de dados primitivos.

Dados Numéricos

Number

O tipo Number representa números em JavaScript, que podem ser inteiros ou fracionários:

Números inteiros, por exemplo, 35. Podemos usar tanto números positivos quanto negativos. O intervalo de números usados vai de -2⁵³ a 2⁵³.

Números fracionários (números de ponto flutuante). Como separador da parte fracionária e inteira, usa-se um ponto, por exemplo, 3.5575. Novamente, podem ser usados números positivos ou negativos. Para números de ponto flutuante, o mesmo intervalo é aplicável: de -2⁵³ a 2⁵³.

Por exemplo:

const x = 45; 
const y = 123.897; 
const z = -0.123;

JavaScript suporta a definição de números em sistemas binário, octal e hexadecimal, o que é muito conveniente para realizar operações de bit a bit com bits individuais de um número. Para definir um número em sistema binário, um prefixo 0b é usado antes do número:

const num1 = 0b1011;    // número 11 em sistema decimal
console.log(num1);      // 11

Neste caso, a constante num1 é igual a 0b1011, o que é equivalente a 11 em sistema decimal.

Para definir um número em sistema octal, um prefixo 0o é usado antes do número:

const num1 = 0o11; // número 9 em sistema decimal
console.log(num1); // 9

Para definir um número em sistema hexadecimal, um prefixo 0x é usado antes do número:

const num1 = 0xff;    // número 255 em sistema decimal
console.log(num1);    // 255
const num2 = 0x1A;    // número 26 em sistema decimal
console.log(num2);    // 26

Desde o padrão ECMA2021 em JavaScript, para aumentar a legibilidade, um sublinhado _ pode ser usado como separador entre dígitos:

const num1 = 1234567;
const num2 = 123_4567; // número igual a num1
const num3 = 1234567890;
const num4 = 12_3456_7890; // número igual a num3

Tipo BigInt

O tipo BigInt foi adicionado nas últimas normas do JavaScript para representar números inteiros muito grandes que ultrapassam os limites do alcance do tipo number. Isso não significa que não podemos trabalhar com números grandes usando o tipo number, mas lidar com eles quando usando o tipo number pode trazer problemas. Vamos considerar um pequeno exemplo:

let num = 9007199254740991
console.log(num);       // 9007199254740991
console.log(num + 1);   // 9007199254740992
console.log(num + 2);   // 9007199254740992

Aqui, a variável num é atribuída o valor máximo. E então adicionamos alguns valores a ela e exibimos o resultado no console. E os resultados podem nos confundir, especialmente no caso de adicionar o número 2.

É importante notar que o tipo Number é limitado, embora permita operar com uma gama bastante grande de números. Em particular, podemos usar as constantes especiais Number.MIN_VALUE e Number.MAX_VALUE para verificar os valores mínimo e máximo possíveis para o tipo Number:

console.log(Number.MIN_VALUE);   // 5e-324
console.log(Number.MAX_VALUE);   // 1.7976931348623157e+308

Por exemplo, consideremos o seguinte exemplo:

const num = 9223372036854775801;
console.log(num);   // 9223372036854776000

Devido às limitações do tipo Number, veremos no console um número um pouco diferente do que atribuímos à constante num. Isso pode afetar negativamente a precisão nos cálculos. E para tais números grandes é que o tipo BigInt é destinado. Para definir um número como um valor do tipo BigInt, um sufixo n é adicionado ao final do número:

let dimension = 19007n;
const value = 2545n;

Por exemplo, mudemos do exemplo anterior o tipo Number para BigInt:

const num = 9223372036854775801n;
console.log(num);   // 9223372036854775801

Agora, o console exibe o resultado correto.

Tipo Boolean

O tipo Boolean representa valores booleanos ou lógicos true (verdadeiro) e false (falso):

const isAlive = true;
const isDead = false;

Cadeias de Caracteres String

O tipo String representa cadeias de caracteres. Para definir cadeias de caracteres, utilizam-se aspas, podendo ser aspas duplas, simples ou invertidas. A única restrição é que o tipo de aspa de fechamento deve ser o mesmo que o tipo de abertura, ou seja, ou ambas são duplas, ou ambas são simples.

const user = "Tom";
const company = 'Microsoft';
const language = `JavaScript`;

console.log(user);
console.log(company);
console.log(language);

Se aspas forem encontradas dentro da cadeia de caracteres, elas devem ser escapadas com uma barra invertida. Por exemplo, se tivermos o texto "Empresa "Burger & Co"", agora vamos escapar as aspas: & Co", agora vamos escapar as aspas:

const company = "Empresa \"Burger & Co\"";

Também podemos usar um tipo diferente de aspas dentro da cadeia:

const company1 = "Empresa 'Burger & Co'"; 
const company2 = 'Empresa "Burger & Co"';

Além disso, a cadeia de caracteres pode conter símbolos especiais - sequências de controle, que são interpretadas de uma maneira específica. As sequências mais comuns são "\n" (nova linha) e "\t" (tabulação). Por exemplo:

const text = "Hello Programício\nHello\tWorld";
console.log(text);

Ao imprimir no console, o texto da constante text será interpretado da seguinte forma:

Hello Programício
Hello	   World

Interpolação

O uso de crases permite aplicar uma técnica conhecida como interpolação, que consiste em embutir dados dentro de uma string. Por exemplo:

const user = "Tom";
const text = `Nome: ${user}`;
console.log(text);  // Nome: Tom

Para incorporar valores de expressões (como valores de outras variáveis e constantes) em uma string, coloca-se o símbolo do dólar $ seguido por chaves, dentro das quais é especificada a expressão. Assim, no exemplo acima, `${user}` indica que o valor da variável user deve ser inserido nesse ponto da string.

Da mesma forma, é possível incorporar uma quantidade maior de dados:

const user = "Tom";
const age = 37;
const isMarried = false;
const text = `Nome: ${user}   Idade: ${age}   Casado: ${isMarried}`;
console.log(text);  // Nome: Tom   Idade: 37   Casado: false

Além da interpolação, as crases também permitem definir textos multilinha:

const text = 
`Todos nós aprendemos um pouco
De alguma coisa e de algum modo,
Assim, com a educação, graças a Deus,
Não é difícil brilhar para nós.`;
  
console.log(text);

Saída no console do navegador:

Todos nós aprendemos um pouco
De alguma coisa e de algum modo,
Assim, com a educação, graças a Deus,
Não é difícil brilhar para nós.

null e undefined

undefined indica que um valor não foi definido ou não está estabelecido. Por exemplo, quando definimos uma variável sem atribuir um valor inicial, ela é do tipo undefined:

let email;
console.log(email); // irá imprimir undefined

Atribuir o valor null significa que a variável não possui valor:

let email;
console.log(email); // undefined
email = null;
console.log(email); // null

Vale notar que, embora seja tecnicamente possível atribuir o valor undefined a uma variável, como no caso a seguir:

let email = "tome@mimimail.com";
email = undefined;  // define o tipo como undefined
console.log(email); // undefined

O principal propósito do undefined é indicar que uma variável não foi inicializada, o que geralmente ocorre antes do primeiro valor ser atribuído a ela. Portanto, normalmente não se espera que uma variável seja explicitamente definida como undefined. No entanto, esse tipo pode ser útil para verificar se uma variável foi inicializada. Mas, se precisarmos indicar que uma variável não possui nenhum valor, então ela deve receber null, e não undefined.

Objeto

O tipo object representa um objeto complexo. A definição mais simples de um objeto usa chaves:

const user = {};

Um objeto pode ter diferentes propriedades e métodos:

const user = {name: "Tom", age: 24};
console.log(user.name);

Neste caso, o objeto é chamado user e ele possui duas propriedades: name e age, que recebem valores de outros tipos como seus valores. Esta é uma breve descrição de objetos; uma explicação mais detalhada será dada em artigos subsequentes.

Tipagem Fraca/Dinâmica

JavaScript é uma linguagem de tipagem fraca e dinâmica. Isso significa que as variáveis podem mudar de tipo dinamicamente. Por exemplo:

let id;  // tipo undefined
console.log(id);
id = 45;  // tipo number
console.log(id);
id = "45"; // tipo string
console.log(id);

Apesar de, no segundo e terceiro casos, o console exibir o número 45, no segundo caso a variável id representa um número, e no terceiro caso, uma string.

Operador typeof

O operador typeof no JavaScript é usado para obter o tipo de uma variável, o que pode ser útil quando, dependendo do tipo da variável, é necessário executar determinadas ações: javascript

let id;
console.log(typeof id);     // undefined

id = 45;
console.log(typeof id);     // number

id = 45n;
console.log(typeof id);     // bigint

id = "45";
console.log(typeof id);     // string

Vale mencionar que, para o valor null o operador typeof retorna "object", apesar de, segundo a especificação do JavaScript, o valor null representar um tipo separado.