Em JavaScript, os valores podem ser classificados em tipos primitivos e o tipo objeto. Compreender esses tipos é fundamental para evitar erros comuns e escrever código previsível. Nesta aula, exploraremos cada tipo, suas particularidades e algumas pegadinhas que podem enganar até programadores experientes.

Tipos primitivos e objeto

JavaScript possui 7 tipos primitivos: string, number, boolean, null, undefined, symbol (ES6) e bigint (ES2020). Todo valor que não é primitivo é um objeto (incluindo arrays, funções, datas, etc.). Primitivos são imutáveis e comparados por valor; objetos são mutáveis e comparados por referência.

// Exemplos de primitivos
const nome = "João"; // string
const idade = 25;     // number
const ativo = true;   // boolean
const nulo = null;    // null
let indefinido;       // undefined
const id = Symbol('id'); // symbol
const grande = 123n;  // bigint

// Objeto
const pessoa = { nome: "João", idade: 25 };
const numeros = [1, 2, 3];
function funcao() {}

Particularidades de cada tipo

String: sequência de caracteres, imutável. Pode ser delimitada por aspas simples, duplas ou crases (template literals).

const msg = "Olá";
const msg2 = 'Mundo';
const template = `Olá, ${nome}!`;

Number: representa números de ponto flutuante (IEEE 754). Inclui valores especiais como Infinity, -Infinity e NaN (Not-a-Number).

console.log(10 / 0);        // Infinity
console.log(-10 / 0);       // -Infinity
console.log(0 / 0);         // NaN
console.log(parseInt("abc")); // NaN

Boolean: apenas dois valores: true e false.

Null: representa a ausência intencional de um valor. É um objeto vazio (mas é primitivo).

Undefined: indica que uma variável foi declarada mas não inicializada.

Symbol: valor único e imutável, usado como chave de propriedade de objeto.

const s1 = Symbol('foo');
const s2 = Symbol('foo');
console.log(s1 === s2); // false

BigInt: para inteiros arbitrariamente grandes. Adiciona-se n ao final.

const big = 1234567890123456789012345678901234567890n;
console.log(big + 1n);

Objeto: coleção de pares chave-valor. Inclui arrays, funções, datas, etc.

const obj = { a: 1 };
const arr = [1, 2, 3];
const fn = () => {};
console.log(typeof obj); // "object"
console.log(typeof arr); // "object"
console.log(typeof fn);  // "function" (mas função é um objeto)

Exemplos

// Verificando tipos
console.log(typeof "texto");     // "string"
console.log(typeof 42);          // "number"
console.log(typeof true);        // "boolean"
console.log(typeof undefined);   // "undefined"
console.log(typeof Symbol());    // "symbol"
console.log(typeof 123n);        // "bigint"
console.log(typeof {});          // "object"
console.log(typeof []);          // "object"
console.log(typeof null);        // "object" (pegadinha!)

// Comparação entre primitivos e objetos
let a = 10;
let b = 10;
console.log(a === b); // true (valor)

let obj1 = { valor: 10 };
let obj2 = { valor: 10 };
console.log(obj1 === obj2); // false (referências diferentes)

Pegadinhas (typeof null, NaN, coerção)

typeof null: retorna "object", um erro histórico do JavaScript. Para verificar null, use valor === null.

console.log(typeof null); // "object" (pegadinha!)
console.log(null === null); // true

NaN: é um valor do tipo number que representa "Not-a-Number". Curiosamente, NaN !== NaN (é o único valor que não é igual a si mesmo). Use Number.isNaN() para verificar.

console.log(typeof NaN); // "number"
console.log(NaN === NaN); // false
console.log(Number.isNaN(NaN)); // true

Coerção de tipos: JavaScript converte tipos automaticamente em operações. Pode causar resultados inesperados.

console.log(1 + "2");        // "12" (number + string = string)
console.log("5" - 3);       // 2 (string convertida para number)
console.log("5" * "2");     // 10
console.log(!"");            // true (string vazia é falsy)
console.log(!0);             // true (0 é falsy)
console.log(!"texto");      // false (string não vazia é truthy)

// Comparações com == (coerção) vs === (sem coerção)
console.log(1 == "1");      // true (coerção)
console.log(1 === "1");     // false (tipos diferentes)
console.log(null == undefined); // true
console.log(null === undefined); // false

Referências

Exercícios

  1. Qual o resultado de typeof null? Explique por que isso acontece.

    O resultado é "object". Isso é um erro histórico do JavaScript que nunca foi corrigido para não quebrar código existente. Para verificar null, use === null.
  2. O que retorna NaN === NaN? Como verificar corretamente se um valor é NaN?

    Retorna false. Para verificar, use Number.isNaN(valor).
  3. Qual é a saída de console.log(1 + "2" + 3)? E de console.log(1 + 2 + "3")? Explique.

    "123" e "33". No primeiro, 1 + "2" vira "12" (concatenação), depois "12" + 3 vira "123". No segundo, 1+2=3 (number), depois 3 + "3" vira "33".
  4. Diferencie null e undefined com exemplos.

    undefined significa que uma variável foi declarada mas não recebeu valor. null é um valor atribuído intencionalmente para representar "vazio". Exemplo: let a; console.log(a); // undefined e let b = null; console.log(b); // null.
  5. O que são tipos primitivos? Cite todos e dê um exemplo de cada.

    Primitivos são valores imutáveis e comparados por valor. São 7: string (ex: "olá"), number (42), boolean (true), null, undefined, symbol (Symbol('id')), bigint (123n).