Tipos de Dados em JavaScript
Imagine que você está organizando uma caixa de ferramentas. Você não colocaria parafusos junto com líquidos, nem misturaria ferramentas elétricas com materiais frágeis. Cada item tem suas características e precisa ser tratado adequadamente.
Na programação, acontece algo similar. Os tipos de dados são como diferentes categorias de informações que o computador precisa processar, e cada tipo tem suas próprias características e regras de uso.
// Assim como na vida real, diferentes tipos requerem tratamento diferente
let idade = 25; // Número - posso fazer cálculos
let nome = "Maria"; // Texto - posso juntar com outras palavras
let aprovado = true; // Verdadeiro/Falso - posso usar em decisões
O Conceito Fundamental: Tipagem Dinâmica
O que é Tipagem Dinâmica?
JavaScript é uma linguagem dinamicamente tipada. Isso significa que você não precisa dizer antecipadamente que tipo de dados uma variável vai guardar - a linguagem descobre isso sozinha baseada no valor que você atribui.
let meuDado;
meuDado = "Olá"; // Agora é texto (string)
console.log(typeof meuDado); // "string"
meuDado = 42; // Agora é número (number)
console.log(typeof meuDado); // "number"
meuDado = true; // Agora é verdadeiro/falso (boolean)
console.log(typeof meuDado); // "boolean"
Por que Isso é Útil?
// Em outras linguagens, você precisaria declarar o tipo:
// int idade = 25; // Apenas números inteiros
// string nome = "João"; // Apenas texto
// Em JavaScript, é mais flexível:
let dadoUsuario = 25; // Número
dadoUsuario = "Vinte e cinco"; // Texto - sem problema!
Os 8 Tipos Fundamentais do JavaScript
JavaScript possui 8 tipos de dados fundamentais, divididos em duas categorias:
📦 Tipos Primitivos (7 tipos)
- Number - Números
- String - Texto
- Boolean - Verdadeiro/Falso
- Null - Valor vazio intencional
- Undefined - Valor não definido
- BigInt - Números muito grandes
- Symbol - Identificadores únicos
🏗️ Tipo Não-Primitivo (1 tipo)
- Object - Objetos (coleções de dados)
Tipo 1: Number (Números)
O tipo number representa tanto números inteiros quanto decimais.
Exemplos Básicos
let idade = 25; // Número inteiro
let altura = 1.75; // Número decimal
let temperatura = -10; // Número negativo
let preco = 29.99; // Preço com centavos
console.log(typeof idade); // "number"
console.log(typeof altura); // "number"
console.log(typeof temperatura); // "number"
Valores Numéricos Especiais
JavaScript possui três valores numéricos especiais que são importantes conhecer:
// Infinity - Infinito positivo
console.log(1 / 0); // Infinity
console.log(typeof (1/0)); // "number"
// -Infinity - Infinito negativo
console.log(-1 / 0); // -Infinity
// NaN - "Not a Number" (Não é um número)
console.log("texto" / 2); // NaN
console.log(0 / 0); // NaN
console.log(typeof NaN); // "number" (curiosamente!)
Tipo 2: String (Texto)
Strings representam texto e devem estar envolvidas por aspas.
// 1. Aspas duplas
let nome = "Maria Silva";
// 2. Aspas simples
let cidade = 'São Paulo';
console.log(typeof nome); // "string"
console.log(typeof cidade); // "string"
Tipo 3: Boolean (Verdadeiro/Falso)
O tipo boolean possui apenas dois valores possíveis: true ou false.
Uso Básico
let aprovado = true;
let reprovado = false;
let maiorIdade = true;
console.log(typeof aprovado); // "boolean"
console.log(typeof reprovado); // "boolean"
console.log(typeof maiorIdade); // "boolean"
Tipo 4: Null (Nulo)
O valor null representa "nada", "vazio" ou "valor desconhecido" de forma intencional.
let dadosUsuario = null; // Intencionalmente vazio
console.log(dadosUsuario); // null
console.log(typeof dadosUsuario); // "object" (isso é um erro histórico!)
Quando Usar Null
// Inicializar variável que receberá dados depois
let fotoPerfilUsuario = null;
// Mais tarde no código...
fotoPerfilUsuario = "caminho/para/foto.jpg";
// Limpar dados intencionalmente
let carrinhoCompras = "itens";
carrinhoCompras = null; // Limpa o carrinho intencionalmente
Tipo 5: Undefined (Indefinido)
O valor undefined significa "valor não foi atribuído" - acontece automaticamente.
let variavel; // Declarada mas não inicializada
console.log(variavel); // undefined
console.log(typeof variavel); // "undefined"
Diferença Entre Null e Undefined
let intencionalmente = null; // "Eu coloquei vazio de propósito"
let esqueci; // "Eu esqueci de colocar um valor"
console.log(intencionalmente); // null
console.log(esqueci); // undefined
Tipo 6: BigInt (Números Muito Grandes)
Para números inteiros extremamente grandes que excedem o limite do tipo number.
// Número normal (tem limite)
let numeroNormal = 123456789012345;
// Número gigante (sem limite prático)
let numeroGigante = 123456789012345678901234567890n; // Note o 'n' no final
console.log(typeof numeroNormal); // "number"
console.log(typeof numeroGigante); // "bigint"
Quando Usar BigInt
// Para IDs muito grandes
let idUsuario = 98765432109876543210n;
// Para cálculos científicos
let distanciaEstrelas = 946073047258080000n; // metros até Alpha Centauri
Tipo 7: Symbol (Símbolos)
Symbols são identificadores únicos, principalmente usados em programação avançada e veremos em cursos posteriores.
Tipo 8: Object (Objetos)
O tipo object é o único tipo não-primitivo e pode armazenar coleções de dados.
Diferentes Tipos de Objetos
// Objeto literal
let pessoa = {
nome: "João",
idade: 30,
ativo: true
};
// Array (é um tipo especial de objeto)
let cores = ["azul", "verde", "vermelho"];
console.log(typeof pessoa); // "object"
console.log(typeof cores); // "object"
Verificando se é Array
let numeros = [1, 2, 3, 4, 5];
console.log(typeof numeros); // "object"
console.log(Array.isArray(numeros)); // true (forma correta de verificar)
Verificando Tipos: O Operador typeof
O operador typeof retorna uma string indicando o tipo do valor.
Sintaxe e Exemplos
// Duas formas de usar typeof
console.log(typeof 42); // "number"
console.log(typeof(42)); // "number" (com parênteses)
// Testando todos os tipos
console.log(typeof 123); // "number"
console.log(typeof "texto"); // "string"
console.log(typeof true); // "boolean"
console.log(typeof undefined); // "undefined"
console.log(typeof null); // "object" (erro histórico!)
console.log(typeof 123n); // "bigint"
console.log(typeof {}); // "object"
console.log(typeof []); // "object"
Próximos passos
Na próxima aula, veremos como operar com esses tipos de dados usando operadores aritméticos. Você aprenderá:
- Como fazer cálculos com números
- Como usar a precedência de operadores
- Como converter entre tipos quando necessário
Lembre-se: A programação é uma jornada de aprendizado constante. Não se preocupe em memorizar tudo - o importante é entender os conceitos fundamentais. Com a prática, tudo ficará mais natural!