Carregando...

null e undefined

Você já viu os booleanos — sim ou não claro. Um programa também precisa dizer às vezes «não há valor aqui.» O JavaScript tem dois vazios comuns: undefined e null. Parecem parecidos, mas cada história é diferente. Aqui separamos os dois para que conversões e checagens depois façam sentido.

Qual é a diferença entre null e undefined?

undefined costuma significar «ainda não colocaram nada» — variável com let sem atribuição, ou algo que falta. null significa «vazio de propósito»: você (ou uma API) atribui null para limpar um lugar. Confira com typeof: typeof undefined é "undefined", mas typeof null é a peculiaridade antiga "object". Prefira === ao comparar. Ambos são falsy, mas não são booleanos (true / false).

Kit de valores vazios

📊 null versus undefined para iniciantes

Ideia Exemplo Resultado / nota
Ausente / sem atribuição let x; depois x undefined
Vazio intencional let box = null você escolhe vazio
typeof ausente typeof undefined "undefined"
typeof vazio typeof null "object" (peculiaridade — ainda significa vazio)
Comparação estrita box === null true quando box guarda null
Comparação frouxa null == undefined true com == — prefira === por clareza

undefined — ainda sem atribuição

Declare um nome com let e não atribua. O valor é undefined. Registre o valor e o typeof para fixar o rótulo "undefined".

undefined por padrão

javascript 
let nickname;
console.log(nickname);
console.log(typeof nickname);

null — vazio de propósito

Atribua null quando quiser sinalizar com clareza «sem valor». Isso é diferente de esquecer a atribuição.

atribuir null de propósito

javascript 
let selected = null;
console.log(selected);
console.log(typeof selected);

typeof lado a lado

Coloque os dois resultados juntos. Lembre: typeof null mostrando "object" é peculiaridade — ainda não é uma lição completa de objetos.

typeof de undefined e null

javascript 
console.log(typeof undefined);
console.log(typeof null);
let a;
let b = null;
console.log(typeof a);
console.log(typeof b);

Prefira === para null e undefined

=== pergunta valor e tipo. Use quando quiser «exatamente null» ou «exatamente undefined». Com ==, null e undefined podem coincidir — fácil de ler mal ao aprender.

checagens estritas com ===

javascript 
let user = null;
let title;
console.log(user === null);
console.log(title === undefined);
console.log(user === undefined);

== frouxo pode misturá-los

Com ==, null e undefined coincidem. Registre uma vez — depois mantenha as checagens reais com ===.

== frouxo entre null e undefined

javascript 
console.log(null == undefined);
console.log(null === undefined);

A primeira linha é true porque == é frouxo. A segunda é false. Escreva as checagens reais com === para manter a intenção clara.

Mostre os dois vazios na página

Guarde um nome no estilo undefined e outro com null, depois escreva rótulos curtos com textContent.

Rótulos de página para null e undefined

html 
<!DOCTYPE html>
<html>
<head>
<title>null and undefined — labels</title>
</head>
<body>
<p id="out">…</p>
<script>
let title;
let avatar = null;
document.getElementById("out").textContent =
"title=" + title + " | avatar=" + avatar;
</script>
</body>
</html>

O parágrafo mostra os dois vazios numa linha. Mude só avatar para uma string curta, atualize e confirme que a metade direita muda enquanto title continua undefined.

Experimente você mesmo

  1. Declare let city; — registre city e typeof city sem atribuir.
  2. Coloque let bag = null; — registre o valor e typeof bag (espere a peculiaridade "object").
  3. Registre typeof undefined e typeof null juntos para ver o contraste.
  4. Compare com ===: uma variável null frente a null e frente a undefined.
  5. Registre uma vez null == undefined; depois escreva as checagens reais com ===.
  6. Na demo HTML, defina avatar como "pic.png", atualize e leia a nova linha.

Erros comuns

  • Tratar null e undefined como sempre intercambiáveis — o significado muda (intencional vs. sem atribuição)
  • Entrar em pânico quando typeof null é "object" — peculiaridade; null continua vazio intencional
  • Confiar em == entre eles sem notar a coincidência frouxa
  • Chamar qualquer um de booleano — são vazios; booleanos são só true / false
  • Confundir a string vazia "" com null — "" ainda é texto

Resumo

  • undefined: ausente / ainda sem atribuição; typeof → "undefined"
  • null: vazio intencional que você atribui; typeof → "object" (peculiaridade)
  • Prefira === para checagens claras; ambos são falsy, mas não booleanos
  • A string vazia "" é texto — não é o mesmo que null ou undefined
  • Próximo: conversão de tipos — transformar de propósito um valor de um tipo em outro

🧠 Teste Seu Conhecimento

Pronto para Começar

Teste Seu Conhecimento

Desafie-se com este questionário interativo e veja o quão bem você entende o tópico

❓
8
Perguntas
🎯
70%
Para Passar
♾️
∞
Tempo
🔄
∞
Tentativas

📝 Instruções

  • Leia cada pergunta cuidadosamente
  • Selecione a melhor resposta para cada pergunta
  • Você pode refazer o quiz quantas vezes quiser
  • Seu progresso será mostrado no topo
Tópico 13 de 16
Javascript Tutorial