Tipos de Dados em JavaScript

Introdução aos Tipos de Dados em JavaScript

JavaScript é uma linguagem tipada dinamicamente: você nunca declara o tipo de uma variável, e ela pode armazenar um valor de qualquer tipo — até mesmo de um tipo diferente posteriormente. Como é o motor de execução, e não você, que rastreia os tipos em tempo de execução, compreender exatamente como cada tipo se comporta é o que separa um código previsível de bugs desconcertantes.

let x = 42;        // x is now a number
x = "forty-two";   // the same variable now holds a string — perfectly legal

A linguagem define oito tipos de dados: sete primitivos e um não primitivo (object). A página abaixo cobre cada um deles, como verificá-los com typeof e as regras de coerção que pegam a maioria dos iniciantes de surpresa.

Tipos de Dados Primitivos

Um primitivo é um valor que não é um object e não possui métodos próprios. Primitivos são imutáveis — você nunca pode alterar um valor primitivo, apenas substituir a variável que o armazena.

• Number: Valores inteiros ou de ponto flutuante, além dos valores especiais Infinity, -Infinity e NaN (Not a Number). Veja Numbers.
• String: Dados textuais, delimitados por aspas duplas, aspas simples ou crases. Veja Strings.
• Boolean: Um de dois valores lógicos, true ou false.
• Undefined: Uma variável que foi declarada mas não recebeu nenhum valor.
• Null: A ausência intencional de qualquer valor de object.
• BigInt: Inteiros além do limite seguro do tipo Number. Veja BigInt.
• Symbol: Um identificador de unicidade garantida, utilizado principalmente como chaves de object. Veja Symbol type.

Tipo de Dado Não Primitivo

• Object: Uma coleção de propriedades chave/valor usada para modelar dados complexos. Arrays, funções, datas e a maioria dos tipos built-in são, internamente, objects. Veja Objects.

Verificando um Tipo com typeof

Para descobrir o tipo de um valor, o JavaScript oferece o operador typeof. Ele retorna uma string como "number", "string" ou "boolean".

Dois resultados surpreendem os iniciantes:

• typeof null retorna "object". Isso é um bug da primeiríssima versão do JavaScript que nunca pode ser corrigido sem quebrar a web — simplesmente memorize.
• typeof de uma função retorna "function". Funções são, de fato, objects, mas typeof as trata de forma especial para que você possa detectar chamáveis.

Trabalhando com Tipos de Dados Primitivos

Abaixo, cada primitivo é apresentado com um exemplo mínimo que você pode executar.

Number: A Base das Operações Matemáticas

let age = 25;       // Integer
let price = 99.99;  // Floating-point
console.log(typeof age);   // "number"
console.log(0.1 + 0.2);    // 0.30000000000000004  (floating-point rounding)

Um único tipo number abrange tanto inteiros quanto decimais. Como os números utilizam ponto flutuante de 64 bits, a aritmética fracionária nem sempre é exata — 0.1 + 0.2 é o exemplo clássico. Os números também incluem Infinity e NaN; NaN é famoso por não ser igual a si mesmo, portanto use Number.isNaN(x) para testá-lo.

String: Muito Mais do que Apenas Texto

let greeting = "Hello, world!";
let name = 'Ada';
let response = `Hi, ${name}!`; // template literal with interpolation
console.log(typeof greeting); // "string"
console.log(response);        // "Hi, Ada!"

Strings são imutáveis: métodos como toUpperCase() retornam uma nova string em vez de alterar a original. Strings com crases (template literals) permitem incorporar ${expressões} e abranger múltiplas linhas. Explore o conjunto completo de ferramentas em Strings.

Boolean: O Tomador de Decisões Binário

let isAvailable = true;
let age = 25;
let isAdult = age >= 18; // comparisons produce booleans
console.log(typeof isAvailable); // "boolean"
console.log(isAdult);            // true

Booleans guiam todo condicional e laço. Qualquer valor também pode ser coercido para um boolean — veja a tabela truthy/falsy abaixo.

Undefined e Null: A Ausência de Valor

let notAssigned;          // declared but never given a value
let emptyOnPurpose = null; // deliberately "nothing"
console.log(typeof notAssigned);  // "undefined"
console.log(typeof emptyOnPurpose); // "object" (the typeof null quirk)
console.log(null == undefined);   // true  (loose equality)
console.log(null === undefined);  // false (strict equality — different types)

Use undefined para "ainda sem valor" (é o que o JavaScript atribui automaticamente), e null para "intencionalmente vazio". Eles são iguais de forma não estrita (==), mas não de forma estrita (===).

BigInt: Lidando com Números Grandes

const big = 9007199254740991n; // note the trailing n
console.log(typeof big);     // "bigint"
console.log(big + 1n);       // 9007199254740992n

Number só pode representar inteiros com segurança até Number.MAX_SAFE_INTEGER (cerca de 9 quatrilhões). Para valores maiores — criptografia, IDs de alta precisão — use BigInt, escrito com um n no final. Você não pode misturar BigInt e Number na mesma operação aritmética sem conversão explícita. Saiba mais em BigInt.

Symbol: Garantindo Unicidade

Cada chamada de Symbol() retorna um valor totalmente novo e único, mesmo que o texto de descrição seja igual. Symbols são usados como chaves de object à prova de colisão, por exemplo para anexar metadados sem conflitar com chaves string normais. Veja Symbol type.

Objects: Os Blocos de Construção de Estruturas Complexas

Em JavaScript, objects armazenam coleções de dados relacionados como pares chave/valor e são a base para arrays, funções e a maioria dos tipos built-in.

let person = {
  name: "John",
  age: 30,
  isStudent: false
};
console.log(typeof person);     // "object"
console.log(typeof [1, 2, 3]);  // "object"  (arrays are objects)
console.log(Array.isArray([1])); // true — the reliable way to detect arrays

Objects são mutáveis — ao contrário dos primitivos, você pode adicionar, alterar e deletar suas propriedades. Eles também são comparados por referência, não por valor: dois objects com conteúdo idêntico não são iguais por ===.

Coerção e Conversão de Tipos

Como JavaScript é tipado dinamicamente, ele frequentemente coerce um valor de um tipo para outro durante uma operação. Isso é conveniente, mas é uma fonte comum de surpresas.

Na dúvida, converta explicitamente com Number(), String() ou Boolean() em vez de depender da coerção automática.

Valores Truthy e Falsy

Quando um valor é usado onde se espera um boolean (em um if, &&, ||), ele é coercido. Exatamente seis valores são falsy; todo o resto é truthy:

// falsy: false, 0, "", null, undefined, NaN
if ("") console.log("won't run");      // "" is falsy
if ("0") console.log("this runs");     // non-empty string is truthy
if ([]) console.log("this runs too");  // empty array is truthy!

Um erro frequente: um array vazio [] e um object vazio {} são truthy, mesmo que "" e 0 sejam falsy.

Resumo

JavaScript possui oito tipos de dados — sete primitivos (number, string, boolean, undefined, null, bigint, symbol) e o object. typeof informa o tipo, com as peculiaridades conhecidas de que typeof null é "object" e funções retornam "function". Primitivos são imutáveis e comparados por valor; objects são mutáveis e comparados por referência. Domine a coerção e as regras de truthy/falsy e a maior parte do "JavaScript estranho" desaparece. A seguir, veja como os valores são armazenados em Variables.

Prática