undefined ou null em JavaScript: como verificar uma variável em 2025

«Variável não definida»: por que essa questão atormenta a todos?

Se você já escreveu em JavaScript pelo menos uma vez, com certeza já se deparou com a situação: executa o código e no console aparece a mensagem vermelha Uncaught TypeError: Cannot read properties of undefined. Ou pior ainda — null is not an object. Familiar? Este é um dos erros mais comuns que persegue desenvolvedores de todos os níveis.

A pergunta «How can I determine if a variable is 'undefined' or 'null'?» no Stack Overflow acumulou milhares de visualizações e centenas de respostas. E não é à toa: em JavaScript, esses dois valores são semelhantes, mas se comportam de maneira diferente. Em 2025, quando o código se torna mais complexo e os projetos mais amplos, saber verificar corretamente undefined e null deixa de ser «bom saber» e passa a ser «obrigatório saber».

Neste artigo, vamos analisar todas as formas de verificação, desde as simples até as avançadas, e mostrar quais métodos vale a pena usar no desenvolvimento moderno. Vamos lá!

undefined vs null: qual a diferença?

Antes de verificar, vamos entender com o que estamos lidando. Em JavaScript, undefined e null são dois valores primitivos diferentes, cada um com seu próprio tipo.

undefined

undefined é o valor atribuído automaticamente a uma variável se você a declarou, mas não definiu um valor. Além disso, uma função retorna undefined se não houver um return explícito.

let myVar;\nconsole.log(myVar); // undefined\n\nfunction doNothing() {}\nconsole.log(doNothing()); // undefined\n\nconsole.log(someNonExistentVariable); // ReferenceError, mas se acessar uma propriedade de um objeto:\nconst obj = {};\nconsole.log(obj.prop); // undefined\n

null

null é um valor atribuído intencionalmente pelo desenvolvedor. Significa «vazio», «nada», «valor ausente». null é um objeto do ponto de vista do typeof (sim, isso é um bug histórico, mas já se tornou uma funcionalidade).

let myVar = null;\nconsole.log(myVar); // null\nconsole.log(typeof myVar); // "object" — sim, é assim!\n

A principal diferença: undefined significa «ainda não atribuído», enquanto null significa «intencionalmente vazio». Mas na comparação não estrita, eles são iguais:

console.log(null == undefined); // true\nconsole.log(null === undefined); // false\n

É justamente por causa dessa igualdade não estrita que surge a confusão. Por isso, as melhores práticas de 2025 recomendam o uso da comparação estrita (===).

Top 5 formas de verificar undefined e null

Vamos analisar todos os métodos populares, dos mais simples aos mais modernos. Avaliaremos cada um por três critérios: legibilidade, confiabilidade e desempenho.

1. Comparação estrita (===) — o padrão ouro

A forma mais direta e compreensível é comparar a variável diretamente com undefined ou null usando ===.

let value = null;\n\n// Verificação de null\nif (value === null) {\n    console.log('Isto é null');\n}\n\n// Verificação de undefined\nif (value === undefined) {\n    console.log('Isto é undefined');\n}\n\n// Verificação de null OU undefined (separadamente)\nif (value === null || value === undefined) {\n    console.log('Valor ausente');\n}\n

Por que esta é a melhor prática?

\n
• Máxima legibilidade — qualquer desenvolvedor entenderá o que você está verificando.
\n
• Sem conversões de tipo inesperadas.
\n
• Funciona em todas as versões do JavaScript, incluindo as mais antigas.
\n

Desvantagem: Se precisar verificar ambos os valores ao mesmo tempo, é necessário escrever duas condições. Mas isso é resolvido com o operador ||, como no exemplo acima.

2. Operador de coalescência nula (??) — novidade que se consolidou

A partir do ES2020, o JavaScript ganhou o operador ?? (nu