null vs undefined no JavaScript: diferenças e quando usar

Dois jeitos de dizer "nada"

A maioria das linguagens tem só um valor pra representar ausência. O JavaScript tem dois: null e undefined. Eles se parecem o suficiente pra confundir quem está começando, e se comportam de formas diferentes o bastante pra pegar desenvolvedores experientes no contrapé. Entender essa diferença entre null e undefined vale dez minutinhos do seu tempo.

Resumindo:

• undefined é o que o JavaScript te entrega quando alguma coisa está faltando.
• null é o que você escreve quando quer dizer "está vazio de propósito".

Repare no padrão: todo undefined que apareceu acima aconteceu porque o JavaScript não encontrou um valor. Já o null apareceu porque alguém digitou ele explicitamente.

De onde vem o undefined

O valor undefined aparece em algumas situações bem específicas no JavaScript, todas variações de "não há valor disponível":

Em todos esses casos, o JavaScript foi buscar um valor e não achou nada. undefined é a forma que o motor tem de dizer: "procurei e não tinha valor nenhum aqui".

Até dá pra atribuir undefined na mão (let x = undefined;), mas não faça isso. Deixa esse valor reservado pro significado dele: "o JavaScript não encontrou nada". Quando a decisão for sua, use null.

De onde vem o null

null só aparece quando alguém escreveu null em algum lugar. E é justamente essa a graça: ele é um marcador intencional.

APIs do DOM usam null o tempo todo: document.getElementById("missing") retorna null, e não undefined, porque o navegador está dizendo explicitamente "procurei e a resposta é: nenhum elemento". O JSON.parse("null") também devolve null — afinal, JSON não tem undefined.

A ideia é essa: undefined é a ausência por padrão, null é uma ausência intencional.

A pegadinha do typeof

Essa aqui é clássica:

typeof null devolver "object" é um bug que existe desde 1995 e que não deu pra corrigir sem quebrar milhares de sites que já estavam no ar — então ficou assim pra sempre. null não é um objeto: é um valor primitivo, igualzinho a undefined, números, strings e booleanos. O typeof simplesmente mente nesse caso.

Na prática, isso quer dizer uma coisa: typeof não serve pra verificar se uma variável é null. O jeito certo é comparar direto:

Ou, o que é bem mais comum, checar os dois de uma vez só — é o que vem a seguir.

Como verificar null e undefined de uma vez: o truque do == null

Na maioria dos casos você nem liga em saber qual dos dois valores ausentes está ali — só quer descobrir se a variável está sem valor antes de usar. O jeito idiomático de fazer isso em JavaScript é com igualdade solta (==) comparando com null:

value == null retorna true exatamente para null e undefined, e false para qualquer outra coisa — inclusive 0, "" e false, que geralmente é o comportamento que você quer. Essa é a única situação em que o == é preferível ao ===. Os linters sabem disso e liberam essa exceção.

Se preferir deixar tudo explícito, value === null || value === undefined significa a mesma coisa e fica bem legível.

Operadores para valores nullish: ?? e ?.

O JavaScript ganhou dois operadores justamente para facilitar a vida na hora de lidar com null e undefined. Os dois tratam esses valores da mesma forma e ignoram todo o resto.

O operador de coalescência nula (??) fornece um valor padrão apenas quando o lado esquerdo é null ou undefined:

Compare com o ||, que substituiria 0 por 3, já que 0 é falsy. O ?? é mais rigoroso: ele só age diante dos dois valores nullish.

O encadeamento opcional (?.) interrompe a avaliação da cadeia e devolve undefined assim que encontra um null ou undefined:

Esses dois operadores existem justamente porque "esse valor é nulo ou indefinido?" é uma pergunta que aparece o tempo todo no código. A gente se aprofunda neles mais pra frente no curso.

Parâmetros padrão só entram em ação com undefined

Tem uma regra sutil mas importante: os valores padrão de parâmetros só são aplicados quando o argumento é undefined, nunca quando é null.

Passar null é tratado como "escolhi explicitamente não ter valor" e respeitado como tal. Se você quiser que null também dispare o fallback, use ?? dentro da função:

Essa diferença confunde bastante gente. Valores default cuidam de argumentos ausentes; o ?? cuida de argumentos nullish.

JSON e a ausência de undefined

O JSON tem null, mas não tem undefined. Isso gera surpresas silenciosas na hora de serializar:

O campo age sumiu por completo — o JSON.stringify descarta propriedades cujo valor é undefined. Já o null sobrevive, porque o JSON tem suporte nativo a ele. Serializar e desserializar um objeto via JSON é uma forma comum de propriedades undefined desaparecerem silenciosamente.

Em arrays, o undefined vira null:

Se você está modelando o payload de uma API, prefira null em vez de undefined para campos "sem valor". Ele sobrevive à viagem.

Quando usar null ou undefined

Uma convenção razoável para o seu próprio código:

• Deixe undefined significar "não informado" — argumentos ausentes, variáveis não definidas, propriedades que não existem. Não atribua undefined na mão.
• Use null quando quiser deixar explícito que "isso está intencionalmente vazio" — um usuário deslogado, uma opção não selecionada, um campo de formulário limpo.
• Aceite os dois nas bordas da sua API (com == null ou ??), mas seja consistente sobre qual dos dois você produz.

Alguns guias de estilo (inclusive o do TypeScript) ignoram null por completo e usam só undefined. É uma escolha defensável — um valor é mais simples que dois. Defina uma regra por projeto e aplique ela em todo lugar.

A seguir: coerção de tipos

null e undefined se comportam de maneiras bem específicas quando o JavaScript converte esses valores para número, string ou booleano — Number(null) dá 0, mas Number(undefined) dá NaN, e esse tipo de assimetria causa bugs de verdade. O próximo tópico é coerção de tipos, e quando você entender as regras completas, muitas das esquisitices do JavaScript deixam de ser um mistério.