0Pricing
Frontend Academy · Aula

Tipos de dados: string, number, boolean, null e undefined

Explore os tipos primitivos do JavaScript, use typeof para inspecioná-los e aprenda a diferença entre null e undefined.

Tipos de dados: string, number, boolean, null e undefined é uma aula grátis de Frontend Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Frontend Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Frontend Academy inclui 4 aulas no total.

O sistema de tipos do JavaScript

JavaScript tem tipagem dinâmica — as variáveis não têm tipos; os valores têm. A mesma variável pode conter uma cadeia de caracteres, depois um número e, em seguida, null. Compreender os sete tipos primitivos evita uma grande categoria de erros.

cadeia de caracteres

Cadeias de caracteres representam texto. Use aspas simples, aspas double ou acento grave (literal de modelo). Elas são imutáveis — os métodos de cadeia de caracteres retornam novas cadeias. As cadeias de caracteres têm uma propriedade .length e muitos métodos integrados.

const greeting = 'Hello';
const lang = "JavaScript";
const sentence = `I love ${lang}`;  // template literal

console.log(greeting.length);   // 5
console.log('hello'.toUpperCase()); // 'HELLO'
console.log(' trim me '.trim()); // 'trim me'

número

JavaScript tem um único tipo numérico. Todos os números — inteiros e números de ponto flutuante — são de ponto flutuante de 64 bits (IEEE 754). Isso significa que 0.1 + 0.2 !== 0.3. Valores especiais: Infinity, -Infinity e NaN (não é um número).

const age = 30;
const price = 19.99;
console.log(0.1 + 0.2);          // 0.30000000000000004
console.log(typeof NaN);          // 'number'
console.log(isNaN('hello'));      // true
console.log(Number.isNaN('hello')); // false (safer check)

booleano

Valores booleanos são true ou false. Eles são usados em condicionais e comparações. Todo valor em JavaScript tem uma veracidade inerente: valores falsos são false, 0, '', null, undefined e NaN. Todo o restante é verdadeiro.

const isActive = true;
const isAdmin = false;

// Falsy values:
if (0) { /* never runs */ }
if ('') { /* never runs */ }
if (null) { /* never runs */ }

null

null é um valor vazio atribuído explicitamente. Significa "nenhum valor intencionalmente". Use null quando quiser limpar uma variável ou indicar ausência. typeof null === 'object' é um famoso erro do JavaScript mantido por compatibilidade com versões antigas.

let selectedUser = null;  // no user selected yet
selectedUser = { name: 'Alice' };
selectedUser = null;       // cleared

undefined

undefined significa que um valor ainda não foi atribuído. Variáveis declaradas, mas não inicializadas, são undefined. Argumentos de função ausentes são undefined. Propriedades ausentes de objetos retornam undefined.

let x;                       // undefined
function greet(name) {
  console.log(name);           // undefined if called as greet()
}
const obj = {};
console.log(obj.foo);         // undefined

null versus undefined

null = ausente intencionalmente. undefined = ainda não atribuído. Como regra: deixe o mecanismo definir undefined; use null explicitamente no seu próprio código quando quiser dizer "vazio".

Operador typeof

Use typeof para inspecionar o tipo de um valor em tempo de execução. Ele retorna uma cadeia de caracteres: 'string', 'number', 'boolean', 'undefined', 'object', 'function', 'bigint', 'symbol'. Lembre-se: typeof null === 'object' é um erro conhecido.

typeof 'hello'     // 'string'
typeof 42          // 'number'
typeof true        // 'boolean'
typeof undefined   // 'undefined'
typeof null        // 'object' ← historical bug
typeof {}          // 'object'
typeof []          // 'object'
typeof function(){} // 'function'

Symbol e BigInt

Symbol: identificador único e imutável — usado em chaves de propriedades de objetos que não entrarão em conflito. BigInt: inteiros maiores que Number.MAX_SAFE_INTEGER (2^53-1). Criado com 42n ou BigInt(42). Não é necessário para a maior parte do trabalho de frontend.

Armadilhas da coerção de tipos

JavaScript converte tipos silenciosamente em comparações e operações. Use === (igualdade estrita), não == (igualdade flexível), para evitar surpresas causadas pela coerção.

0 == false        // true (coercion)
0 === false       // false (strict, no coercion)
'' == false       // true
'5' == 5          // true
'5' === 5         // false ✓ use this

Conversão de tipos

Converta tipos explicitamente com Number(), String(), Boolean() ou parseInt() / parseFloat(). A conversão explícita é sempre mais clara do que depender da coerção.

Number('42')      // 42
Number('')        // 0
Number('abc')     // NaN
String(42)        // '42'
Boolean(0)        // false
Boolean('hello')  // true
parseInt('10px')  // 10

Verificação rápida

O que typeof null retorna em JavaScript?

Recapitulação: tipos de dados do JavaScript

Sete tipos primitivos: string, number, boolean, null, undefined, symbol, bigint. Use typeof para inspecionar tipos. Use === em comparações para evitar coerção. Diferencie null (vazio intencional) de undefined (ainda não definido). Todos os outros valores são objetos.

Perguntas Frequentes

A aula “Tipos de dados: string, number, boolean, null e undefined” é grátis?

Sim — o texto completo de “Tipos de dados: string, number, boolean, null e undefined” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Frontend Academy, atualize para CoddyKit PRO. O curso de Frontend Academy inclui 4 aulas no total.

O que vou aprender em “Tipos de dados: string, number, boolean, null e undefined”?

Explore os tipos primitivos do JavaScript, use typeof para inspecioná-los e aprenda a diferença entre null e undefined. Você pratica Frontend Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Frontend Academy?

Nenhuma experiência prévia é necessária. Frontend Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Tipos de dados: string, number, boolean, null e undefined”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Frontend Academy?

Sim. Cada aula de Frontend Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Variáveis: let, const, var e escopo
  2. Tipos de dados: string, number, boolean, null e undefined
  3. Funções: declarações, expressões e funções de seta
  4. Fluxo de controle: if, else, switch, for e while
← Voltar para Frontend Academy