JavaScript Tipos de Dados

Em JavaScript, todos os dados manipulados pertencem a um tipo específico. No total, a linguagem possui oito tipos de dados, divididos entre tipos primitivos e tipos complexos.

Os tipos primitivos são os mais básicos e imutáveis:

• String: representa uma sequência de caracteres, usada para armazenar textos.

• Number: representa um valor numérico, podendo ser inteiros ou de ponto flutuante.

• BigInt: permite trabalhar com números inteiros extremamente grandes, além do limite do tipo Number.

• Boolean: representa valores lógicos, podendo ser true (verdadeiro) ou false (falso).

• Undefined: indica que uma variável foi declarada, mas ainda não recebeu um valor.

• Null: representa a ausência intencional de valor.

• Symbol: cria identificadores únicos, frequentemente usados como chaves de propriedades em objetos.

Além desses, há um tipo complexo:

• Object: representa uma estrutura de dados mais sofisticada, permitindo armazenar coleções de valores e métodos.

Cada um desses tipos tem seu próprio comportamento e uso específico dentro do JavaScript.

Dados Numéricos

Number

O tipo Number representa valores numéricos em JavaScript, abrangendo tanto números inteiros quanto números fracionários (de ponto flutuante).

Números inteiros:

Podem ser positivos ou negativos, por exemplo, 35 ou -42. Existe um intervalo seguro para representar números inteiros com precisão garantida, indo de -(2⁵³ - 1) até (2⁵³ - 1).

Números Fracionários (Ponto Flutuante)

Números fracionários, também chamados de números de ponto flutuante, utilizam um ponto . para separar a parte inteira da parte fracionária. Exemplos incluem 3.5575 ou -0.25. Esses valores podem ser positivos ou negativos e possuem um intervalo bem mais amplo do que o dos números inteiros seguros, indo até aproximadamente ±1.7976931348623157e+308.

Sistemas Binário, Octal e Hexadecimal

O JavaScript permite definir números em diferentes bases numéricas:

• Binário (prefixo 0b)

  content_copyopen_in_new

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

• Octal (prefixo 0o)

  content_copyopen_in_new

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

• Hexadecimal (prefixo 0x)

  content_copyopen_in_new

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

Essas representações são úteis para manipulações bit a bit e certas aplicações computacionais.

Desde o ECMAScript 2021, para melhorar a legibilidade, é possível usar um sublinhado _ como separador de 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

BigInt

O tipo BigInt foi introduzido no ECMAScript 2020 para representar números inteiros muito grandes, que ultrapassam os limites do tipo Number.

Por que BigInt é necessário?

Embora seja possível lidar com números grandes usando Number, há limitações de precisão ao ultrapassar o intervalo seguro.

Exemplo de erro ao usar Number:

let num = 9007199254740991;
console.log(num);       // 9007199254740991
console.log(num + 1);   // 9007199254740992
console.log(num + 2);   // 9007199254740992 (erro de precisão!)

Neste caso, ao somar 2, o JavaScript retorna o mesmo número, pois a precisão do Number não é suficiente para representá-lo corretamente.

Para lidar com esse problema, usamos BigInt, adicionando o sufixo n ao número:

Se quisermos usar BigInt corretamente, devemos declarar o número com o sufixo n desde o início:

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

Agora, o console exibe o valor correto, sem perda de precisão.

Limitações do tipo Number

O tipo Number possui um intervalo de valores seguros que podem ser representados com precisão. Podemos verificar esses limites usando as constantes:

console.log(Number.MIN_SAFE_INTEGER);  // -9007199254740991
console.log(Number.MAX_SAFE_INTEGER);  //  9007199254740991

Se tentarmos armazenar valores acima desse intervalo usando Number, ocorrerá perda de precisão.

Por exemplo:

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

Boolean

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

const isAlive = true;
const isDead = false;

String

O tipo String representa cadeias de caracteres, utilizadas para armazenar textos.

Para definir strings em JavaScript, podem ser usadas aspas duplas ", aspas simples ' ou crases `:

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

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

A única regra é que o tipo de aspas usado para abrir a string deve ser o mesmo para fechá-la.

Caso seja necessário incluir aspas dentro da string, podemos:

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

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

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

Além disso, a string pode conter símbolos especiais - sequências de escape, 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 de Strings

Usando crases `, podemos inserir variáveis e expressões dentro de uma string por meio da interpolação, utilizando ${}:

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

A interpolação também permite incorporar múltiplas variáveis:

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 disso, strings com crases suportam múltiplas linhas:

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.

Undefined e Null

Undefined

O tipo Undefined indica que uma variável foi declarada, mas ainda não recebeu um valor. Quando isso acontece, seu valor padrão é undefined.

Por exemplo, ao declarar uma variável sem atribuir um valor, ela automaticamente recebe undefined:

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

Null

Atribuir o valor null representa a ausência intencional de um 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;  // atribuindo undefined explicitamente
console.log(email); // undefined

Isso não é recomendado, pois o JavaScript já atribui undefined automaticamente para variáveis não inicializadas. Se for necessário indicar que uma variável não possui valor intencionalmente, o ideal é utilizar null.

Resumo prático:

• Use undefined quando uma variável não foi inicializada.

• Use null para indicar que a variável não possui valor de forma intencional.

Object

O tipo Object representa uma estrutura de dados mais complexa, permitindo armazenar coleções de valores. A forma mais simples de definir um objeto é utilizando chaves {}:

Objetos podem conter propriedades e métodos:

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

Os valores dentro do objeto podem ser de diferentes tipos, como números, strings, arrays e até mesmo outros objetos.

Uma explicação mais detalhada sobre objetos será explorada nos próximos artigos.

Tipagem Fraca e Dinâmica

O JavaScript é uma linguagem de tipagem fraca e dinâmica, o que significa que uma variável pode mudar de tipo ao longo do código.

Exemplo:

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

Embora o console exiba 45 nas duas últimas atribuições, no segundo caso a variável é um número, e no terceiro caso, uma string.

Isso acontece porque o JavaScript converte os tipos automaticamente quando necessário.

Operador typeof

O operador typeof permite verificar o tipo de um valor ou variável:

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"

Nota: typeof null retorna "object", apesar de null ser um tipo primitivo. Isso é um erro histórico do JavaScript.

Resumo

• number é usado para representar valores numéricos inteiros e de ponto flutuante.

  O intervalo seguro para números inteiros vai de -(2⁵³ - 1) até (2⁵³ - 1). Para valores acima desse intervalo, o tipo BigInt deve ser utilizado.

  É possível representar números em bases binária, octal e hexadecimal.

• boolean representa valores lógicos true e false.

• string pode ser definido com aspas simples, duplas ou crases e suporta interpolação e múltiplas linhas.

• undefined é atribuído automaticamente quando uma variável não recebe valor, enquanto null representa ausência de valor intencional.

• object armazena coleções de valores e métodos.

• O JavaScript possui tipagem dinâmica e fraca, permitindo que variáveis mudem de tipo.

• O operador typeof é usado para verificar o tipo de uma variável.

Nos próximos artigos, exploraremos cada um desses tipos com mais detalhes, além de aprender a manipulá-los e utilizá-los em diferentes situações.